Pre: Iterators shouldn't wrap values in options

Signed-off-by: Victor Porof <victor.porof@gmail.com>

examples/simple-store.rs

@@ -35,7 +35,7 @@ fn getput<'w, 's>(store: MultiStore, writer: &'w mut Writer, ids: &'s mut Vec<St
         // this is a multi-valued database, so get returns an iterator
         let mut iter = store.get(writer, k).unwrap();
         while let Some(Ok((_key, val))) = iter.next() {
-            if let Value::Str(s) = val.unwrap() {
+            if let Value::Str(s) = val {
                 ids.push(s.to_owned());
             } else {
                 panic!("didn't get a string back!");

src/helpers.rs

@@ -23,10 +23,9 @@ use crate::{
     value::Value,
 };
 
-pub(crate) fn read_transform(value: Result<&[u8], StoreError>) -> Result<Option<Value>, StoreError> {
+pub(crate) fn read_transform(value: Result<&[u8], StoreError>) -> Result<Value, StoreError> {
     match value {
-        Ok(bytes) => Value::from_tagged_slice(bytes).map(Some).map_err(StoreError::DataError),
-        Err(StoreError::KeyValuePairNotFound) => Ok(None),
+        Ok(bytes) => Value::from_tagged_slice(bytes).map_err(StoreError::DataError),
         Err(e) => Err(e),
     }
 }

src/readwrite.rs

@@ -48,7 +48,10 @@ where
         K: AsRef<[u8]>,
     {
         let bytes = self.0.get(db, k.as_ref()).map_err(|e| e.into());
-        read_transform(bytes)
+        match read_transform(bytes).map(Some) {
+            Err(StoreError::KeyValuePairNotFound) => Ok(None),
+            result => result,
+        }
     }
 
     fn open_ro_cursor(&'r self, db: &T::Database) -> Result<T::RoCursor, StoreError> {
@@ -83,7 +86,10 @@ where
         K: AsRef<[u8]>,
     {
         let bytes = self.0.get(db, k.as_ref()).map_err(|e| e.into());
-        read_transform(bytes)
+        match read_transform(bytes).map(Some) {
+            Err(StoreError::KeyValuePairNotFound) => Ok(None),
+            result => result,
+        }
     }
 
     fn open_ro_cursor(&'r self, db: &T::Database) -> Result<T::RoCursor, StoreError> {

src/store/integermulti.rs

@@ -219,8 +219,8 @@ mod tests {
             s.put(&mut writer, 1, &Value::Str("hello1!")).expect("write");
 
             let mut iter = s.get(&writer, 1).expect("read");
-            assert_eq!(iter.next().expect("first").expect("ok").1, Some(Value::Str("hello!")));
-            assert_eq!(iter.next().expect("second").expect("ok").1, Some(Value::Str("hello1!")));
+            assert_eq!(iter.next().expect("first").expect("ok").1, Value::Str("hello!"));
+            assert_eq!(iter.next().expect("second").expect("ok").1, Value::Str("hello1!"));
             assert!(iter.next().is_none());
         }
     }
@@ -240,8 +240,8 @@ mod tests {
             s.put(&mut writer, 1, &Value::Str("hello1!")).expect("write");
             {
                 let mut iter = s.get(&writer, 1).expect("read");
-                assert_eq!(iter.next().expect("first").expect("ok").1, Some(Value::Str("hello!")));
-                assert_eq!(iter.next().expect("second").expect("ok").1, Some(Value::Str("hello1!")));
+                assert_eq!(iter.next().expect("first").expect("ok").1, Value::Str("hello!"));
+                assert_eq!(iter.next().expect("second").expect("ok").1, Value::Str("hello1!"));
                 assert!(iter.next().is_none());
             }
             writer.commit().expect("committed");
@@ -254,7 +254,7 @@ mod tests {
 
             let reader = k.read().expect("reader");
             let mut iter = s.get(&reader, 1).expect("read");
-            assert_eq!(iter.next().expect("first").expect("ok").1, Some(Value::Str("hello1!")));
+            assert_eq!(iter.next().expect("first").expect("ok").1, Value::Str("hello1!"));
             assert!(iter.next().is_none());
         }
 
@@ -265,7 +265,7 @@ mod tests {
 
             let reader = k.read().expect("reader");
             let mut iter = s.get(&reader, 1).expect("read");
-            assert_eq!(iter.next().expect("first").expect("ok").1, Some(Value::Str("hello1!")));
+            assert_eq!(iter.next().expect("first").expect("ok").1, Value::Str("hello1!"));
             assert!(iter.next().is_none());
         }
 
@@ -305,8 +305,8 @@ mod tests {
             s.put(&mut writer, 2, &Value::Str("hello!")).expect("write");
             {
                 let mut iter = s.get(&writer, 1).expect("read");
-                assert_eq!(iter.next().expect("first").expect("ok").1, Some(Value::Str("hello!")));
-                assert_eq!(iter.next().expect("second").expect("ok").1, Some(Value::Str("hello1!")));
+                assert_eq!(iter.next().expect("first").expect("ok").1, Value::Str("hello!"));
+                assert_eq!(iter.next().expect("second").expect("ok").1, Value::Str("hello1!"));
                 assert!(iter.next().is_none());
             }
             writer.commit().expect("committed");
@@ -318,8 +318,8 @@ mod tests {
 
             let reader = k.read().expect("reader");
             let mut iter = s.get(&reader, 1).expect("read");
-            assert_eq!(iter.next().expect("first").expect("ok").1, Some(Value::Str("hello!")));
-            assert_eq!(iter.next().expect("second").expect("ok").1, Some(Value::Str("hello1!")));
+            assert_eq!(iter.next().expect("first").expect("ok").1, Value::Str("hello!"));
+            assert_eq!(iter.next().expect("second").expect("ok").1, Value::Str("hello1!"));
             assert!(iter.next().is_none());
         }
     }
@@ -436,8 +436,8 @@ mod tests_safe {
             s.put(&mut writer, 1, &Value::Str("hello1!")).expect("write");
 
             let mut iter = s.get(&writer, 1).expect("read");
-            assert_eq!(iter.next().expect("first").expect("ok").1, Some(Value::Str("hello!")));
-            assert_eq!(iter.next().expect("second").expect("ok").1, Some(Value::Str("hello1!")));
+            assert_eq!(iter.next().expect("first").expect("ok").1, Value::Str("hello!"));
+            assert_eq!(iter.next().expect("second").expect("ok").1, Value::Str("hello1!"));
             assert!(iter.next().is_none());
         }
     }
@@ -457,8 +457,8 @@ mod tests_safe {
             s.put(&mut writer, 1, &Value::Str("hello1!")).expect("write");
             {
                 let mut iter = s.get(&writer, 1).expect("read");
-                assert_eq!(iter.next().expect("first").expect("ok").1, Some(Value::Str("hello!")));
-                assert_eq!(iter.next().expect("second").expect("ok").1, Some(Value::Str("hello1!")));
+                assert_eq!(iter.next().expect("first").expect("ok").1, Value::Str("hello!"));
+                assert_eq!(iter.next().expect("second").expect("ok").1, Value::Str("hello1!"));
                 assert!(iter.next().is_none());
             }
             writer.commit().expect("committed");
@@ -471,7 +471,7 @@ mod tests_safe {
 
             let reader = k.read().expect("reader");
             let mut iter = s.get(&reader, 1).expect("read");
-            assert_eq!(iter.next().expect("first").expect("ok").1, Some(Value::Str("hello1!")));
+            assert_eq!(iter.next().expect("first").expect("ok").1, Value::Str("hello1!"));
             assert!(iter.next().is_none());
         }
 
@@ -482,7 +482,7 @@ mod tests_safe {
 
             let reader = k.read().expect("reader");
             let mut iter = s.get(&reader, 1).expect("read");
-            assert_eq!(iter.next().expect("first").expect("ok").1, Some(Value::Str("hello1!")));
+            assert_eq!(iter.next().expect("first").expect("ok").1, Value::Str("hello1!"));
             assert!(iter.next().is_none());
         }
 
@@ -522,8 +522,8 @@ mod tests_safe {
             s.put(&mut writer, 2, &Value::Str("hello!")).expect("write");
             {
                 let mut iter = s.get(&writer, 1).expect("read");
-                assert_eq!(iter.next().expect("first").expect("ok").1, Some(Value::Str("hello!")));
-                assert_eq!(iter.next().expect("second").expect("ok").1, Some(Value::Str("hello1!")));
+                assert_eq!(iter.next().expect("first").expect("ok").1, Value::Str("hello!"));
+                assert_eq!(iter.next().expect("second").expect("ok").1, Value::Str("hello1!"));
                 assert!(iter.next().is_none());
             }
             writer.commit().expect("committed");
@@ -535,8 +535,8 @@ mod tests_safe {
 
             let reader = k.read().expect("reader");
             let mut iter = s.get(&reader, 1).expect("read");
-            assert_eq!(iter.next().expect("first").expect("ok").1, Some(Value::Str("hello!")));
-            assert_eq!(iter.next().expect("second").expect("ok").1, Some(Value::Str("hello1!")));
+            assert_eq!(iter.next().expect("first").expect("ok").1, Value::Str("hello!"));
+            assert_eq!(iter.next().expect("second").expect("ok").1, Value::Str("hello1!"));
             assert!(iter.next().is_none());
         }
     }

src/store/multi.rs

@@ -123,7 +123,7 @@ impl<'i, I> Iterator for Iter<'i, I>
 where
     I: BackendIter<'i>,
 {
-    type Item = Result<(&'i [u8], Option<Value<'i>>), StoreError>;
+    type Item = Result<(&'i [u8], Value<'i>), StoreError>;
 
     fn next(&mut self) -> Option<Self::Item> {
         match self.iter.next() {

src/store/single.rs

@@ -128,7 +128,7 @@ impl<'i, I> Iterator for Iter<'i, I>
 where
     I: BackendIter<'i>,
 {
-    type Item = Result<(&'i [u8], Option<Value<'i>>), StoreError>;
+    type Item = Result<(&'i [u8], Value<'i>), StoreError>;
 
     fn next(&mut self) -> Option<Self::Item> {
         match self.iter.next() {

tests/env-lmdb.rs

@@ -432,9 +432,9 @@ fn test_multi_put_get_del() {
     {
         let mut iter = multistore.get(&writer, "str1").unwrap();
         let (id, val) = iter.next().unwrap().unwrap();
-        assert_eq!((id, val), (&b"str1"[..], Some(Value::Str("str1 bar"))));
+        assert_eq!((id, val), (&b"str1"[..], Value::Str("str1 bar")));
         let (id, val) = iter.next().unwrap().unwrap();
-        assert_eq!((id, val), (&b"str1"[..], Some(Value::Str("str1 foo"))));
+        assert_eq!((id, val), (&b"str1"[..], Value::Str("str1 foo")));
     }
     writer.commit().unwrap();
 
@@ -866,22 +866,22 @@ fn test_iter() {
     let mut iter = sk.iter_start(&reader).unwrap();
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "bar");
-    assert_eq!(val, Some(Value::Bool(true)));
+    assert_eq!(val, Value::Bool(true));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "baz");
-    assert_eq!(val, Some(Value::Str("héllo, yöu")));
+    assert_eq!(val, Value::Str("héllo, yöu"));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "foo");
-    assert_eq!(val, Some(Value::I64(1234)));
+    assert_eq!(val, Value::I64(1234));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "héllò, töűrîst");
-    assert_eq!(val, Some(Value::Str("Emil.RuleZ!")));
+    assert_eq!(val, Value::Str("Emil.RuleZ!"));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "noo");
-    assert_eq!(val, Some(Value::F64(1234.0.into())));
+    assert_eq!(val, Value::F64(1234.0.into()));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
-    assert_eq!(val, Some(Value::Str("米克規則")));
+    assert_eq!(val, Value::Str("米克規則"));
     assert!(iter.next().is_none());
 
     // Iterators don't loop.  Once one returns None, additional calls
@@ -893,10 +893,10 @@ fn test_iter() {
     let mut iter = sk.iter_from(&reader, "moo").unwrap();
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "noo");
-    assert_eq!(val, Some(Value::F64(1234.0.into())));
+    assert_eq!(val, Value::F64(1234.0.into()));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
-    assert_eq!(val, Some(Value::Str("米克規則")));
+    assert_eq!(val, Value::Str("米克規則"));
     assert!(iter.next().is_none());
 
     // Reader.iter_from() works as expected when the given key is a prefix
@@ -904,10 +904,10 @@ fn test_iter() {
     let mut iter = sk.iter_from(&reader, "no").unwrap();
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "noo");
-    assert_eq!(val, Some(Value::F64(1234.0.into())));
+    assert_eq!(val, Value::F64(1234.0.into()));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
-    assert_eq!(val, Some(Value::Str("米克規則")));
+    assert_eq!(val, Value::Str("米克規則"));
     assert!(iter.next().is_none());
 }
 
@@ -1002,84 +1002,84 @@ fn test_multiple_store_iter() {
     let mut iter = s1.iter_start(&reader).unwrap();
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "bar");
-    assert_eq!(val, Some(Value::Bool(true)));
+    assert_eq!(val, Value::Bool(true));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "baz");
-    assert_eq!(val, Some(Value::Str("héllo, yöu")));
+    assert_eq!(val, Value::Str("héllo, yöu"));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "foo");
-    assert_eq!(val, Some(Value::I64(1234)));
+    assert_eq!(val, Value::I64(1234));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "héllò, töűrîst");
-    assert_eq!(val, Some(Value::Str("Emil.RuleZ!")));
+    assert_eq!(val, Value::Str("Emil.RuleZ!"));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "noo");
-    assert_eq!(val, Some(Value::F64(1234.0.into())));
+    assert_eq!(val, Value::F64(1234.0.into()));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
-    assert_eq!(val, Some(Value::Str("米克規則")));
+    assert_eq!(val, Value::Str("米克規則"));
     assert!(iter.next().is_none());
 
     // Iterate through the whole store in "s2"
     let mut iter = s2.iter_start(&reader).unwrap();
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "bar");
-    assert_eq!(val, Some(Value::Bool(true)));
+    assert_eq!(val, Value::Bool(true));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "baz");
-    assert_eq!(val, Some(Value::Str("héllo, yöu")));
+    assert_eq!(val, Value::Str("héllo, yöu"));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "foo");
-    assert_eq!(val, Some(Value::I64(1234)));
+    assert_eq!(val, Value::I64(1234));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "héllò, töűrîst");
-    assert_eq!(val, Some(Value::Str("Emil.RuleZ!")));
+    assert_eq!(val, Value::Str("Emil.RuleZ!"));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "noo");
-    assert_eq!(val, Some(Value::F64(1234.0.into())));
+    assert_eq!(val, Value::F64(1234.0.into()));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
-    assert_eq!(val, Some(Value::Str("米克規則")));
+    assert_eq!(val, Value::Str("米克規則"));
     assert!(iter.next().is_none());
 
     // Iterate from a given key in "s1"
     let mut iter = s1.iter_from(&reader, "moo").unwrap();
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "noo");
-    assert_eq!(val, Some(Value::F64(1234.0.into())));
+    assert_eq!(val, Value::F64(1234.0.into()));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
-    assert_eq!(val, Some(Value::Str("米克規則")));
+    assert_eq!(val, Value::Str("米克規則"));
     assert!(iter.next().is_none());
 
     // Iterate from a given key in "s2"
     let mut iter = s2.iter_from(&reader, "moo").unwrap();
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "noo");
-    assert_eq!(val, Some(Value::F64(1234.0.into())));
+    assert_eq!(val, Value::F64(1234.0.into()));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
-    assert_eq!(val, Some(Value::Str("米克規則")));
+    assert_eq!(val, Value::Str("米克規則"));
     assert!(iter.next().is_none());
 
     // Iterate from a given prefix in "s1"
     let mut iter = s1.iter_from(&reader, "no").unwrap();
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "noo");
-    assert_eq!(val, Some(Value::F64(1234.0.into())));
+    assert_eq!(val, Value::F64(1234.0.into()));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
-    assert_eq!(val, Some(Value::Str("米克規則")));
+    assert_eq!(val, Value::Str("米克規則"));
     assert!(iter.next().is_none());
 
     // Iterate from a given prefix in "s2"
     let mut iter = s2.iter_from(&reader, "no").unwrap();
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "noo");
-    assert_eq!(val, Some(Value::F64(1234.0.into())));
+    assert_eq!(val, Value::F64(1234.0.into()));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
-    assert_eq!(val, Some(Value::Str("米克規則")));
+    assert_eq!(val, Value::Str("米克規則"));
     assert!(iter.next().is_none());
 }
 

tests/env-safe.rs

@@ -352,9 +352,9 @@ fn test_multi_put_get_del_safe() {
     {
         let mut iter = multistore.get(&writer, "str1").unwrap();
         let (id, val) = iter.next().unwrap().unwrap();
-        assert_eq!((id, val), (&b"str1"[..], Some(Value::Str("str1 bar"))));
+        assert_eq!((id, val), (&b"str1"[..], Value::Str("str1 bar")));
         let (id, val) = iter.next().unwrap().unwrap();
-        assert_eq!((id, val), (&b"str1"[..], Some(Value::Str("str1 foo"))));
+        assert_eq!((id, val), (&b"str1"[..], Value::Str("str1 foo")));
     }
     writer.commit().unwrap();
 
@@ -685,22 +685,22 @@ fn test_iter_safe() {
     let mut iter = sk.iter_start(&reader).unwrap();
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "bar");
-    assert_eq!(val, Some(Value::Bool(true)));
+    assert_eq!(val, Value::Bool(true));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "baz");
-    assert_eq!(val, Some(Value::Str("héllo, yöu")));
+    assert_eq!(val, Value::Str("héllo, yöu"));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "foo");
-    assert_eq!(val, Some(Value::I64(1234)));
+    assert_eq!(val, Value::I64(1234));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "héllò, töűrîst");
-    assert_eq!(val, Some(Value::Str("Emil.RuleZ!")));
+    assert_eq!(val, Value::Str("Emil.RuleZ!"));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "noo");
-    assert_eq!(val, Some(Value::F64(1234.0.into())));
+    assert_eq!(val, Value::F64(1234.0.into()));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
-    assert_eq!(val, Some(Value::Str("米克規則")));
+    assert_eq!(val, Value::Str("米克規則"));
     assert!(iter.next().is_none());
 
     // Iterators don't loop.  Once one returns None, additional calls
@@ -712,10 +712,10 @@ fn test_iter_safe() {
     let mut iter = sk.iter_from(&reader, "moo").unwrap();
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "noo");
-    assert_eq!(val, Some(Value::F64(1234.0.into())));
+    assert_eq!(val, Value::F64(1234.0.into()));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
-    assert_eq!(val, Some(Value::Str("米克規則")));
+    assert_eq!(val, Value::Str("米克規則"));
     assert!(iter.next().is_none());
 
     // Reader.iter_from() works as expected when the given key is a prefix
@@ -723,10 +723,10 @@ fn test_iter_safe() {
     let mut iter = sk.iter_from(&reader, "no").unwrap();
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "noo");
-    assert_eq!(val, Some(Value::F64(1234.0.into())));
+    assert_eq!(val, Value::F64(1234.0.into()));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
-    assert_eq!(val, Some(Value::Str("米克規則")));
+    assert_eq!(val, Value::Str("米克規則"));
     assert!(iter.next().is_none());
 }
 
@@ -822,84 +822,84 @@ fn test_multiple_store_iter_safe() {
     let mut iter = s1.iter_start(&reader).unwrap();
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "bar");
-    assert_eq!(val, Some(Value::Bool(true)));
+    assert_eq!(val, Value::Bool(true));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "baz");
-    assert_eq!(val, Some(Value::Str("héllo, yöu")));
+    assert_eq!(val, Value::Str("héllo, yöu"));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "foo");
-    assert_eq!(val, Some(Value::I64(1234)));
+    assert_eq!(val, Value::I64(1234));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "héllò, töűrîst");
-    assert_eq!(val, Some(Value::Str("Emil.RuleZ!")));
+    assert_eq!(val, Value::Str("Emil.RuleZ!"));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "noo");
-    assert_eq!(val, Some(Value::F64(1234.0.into())));
+    assert_eq!(val, Value::F64(1234.0.into()));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
-    assert_eq!(val, Some(Value::Str("米克規則")));
+    assert_eq!(val, Value::Str("米克規則"));
     assert!(iter.next().is_none());
 
     // Iterate through the whole store in "s2"
     let mut iter = s2.iter_start(&reader).unwrap();
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "bar");
-    assert_eq!(val, Some(Value::Bool(true)));
+    assert_eq!(val, Value::Bool(true));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "baz");
-    assert_eq!(val, Some(Value::Str("héllo, yöu")));
+    assert_eq!(val, Value::Str("héllo, yöu"));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "foo");
-    assert_eq!(val, Some(Value::I64(1234)));
+    assert_eq!(val, Value::I64(1234));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "héllò, töűrîst");
-    assert_eq!(val, Some(Value::Str("Emil.RuleZ!")));
+    assert_eq!(val, Value::Str("Emil.RuleZ!"));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "noo");
-    assert_eq!(val, Some(Value::F64(1234.0.into())));
+    assert_eq!(val, Value::F64(1234.0.into()));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
-    assert_eq!(val, Some(Value::Str("米克規則")));
+    assert_eq!(val, Value::Str("米克規則"));
     assert!(iter.next().is_none());
 
     // Iterate from a given key in "s1"
     let mut iter = s1.iter_from(&reader, "moo").unwrap();
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "noo");
-    assert_eq!(val, Some(Value::F64(1234.0.into())));
+    assert_eq!(val, Value::F64(1234.0.into()));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
-    assert_eq!(val, Some(Value::Str("米克規則")));
+    assert_eq!(val, Value::Str("米克規則"));
     assert!(iter.next().is_none());
 
     // Iterate from a given key in "s2"
     let mut iter = s2.iter_from(&reader, "moo").unwrap();
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "noo");
-    assert_eq!(val, Some(Value::F64(1234.0.into())));
+    assert_eq!(val, Value::F64(1234.0.into()));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
-    assert_eq!(val, Some(Value::Str("米克規則")));
+    assert_eq!(val, Value::Str("米克規則"));
     assert!(iter.next().is_none());
 
     // Iterate from a given prefix in "s1"
     let mut iter = s1.iter_from(&reader, "no").unwrap();
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "noo");
-    assert_eq!(val, Some(Value::F64(1234.0.into())));
+    assert_eq!(val, Value::F64(1234.0.into()));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
-    assert_eq!(val, Some(Value::Str("米克規則")));
+    assert_eq!(val, Value::Str("米克規則"));
     assert!(iter.next().is_none());
 
     // Iterate from a given prefix in "s2"
     let mut iter = s2.iter_from(&reader, "no").unwrap();
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "noo");
-    assert_eq!(val, Some(Value::F64(1234.0.into())));
+    assert_eq!(val, Value::F64(1234.0.into()));
     let (key, val) = iter.next().unwrap().unwrap();
     assert_eq!(str::from_utf8(key).expect("key"), "你好，遊客");
-    assert_eq!(val, Some(Value::Str("米克規則")));
+    assert_eq!(val, Value::Str("米克規則"));
     assert!(iter.next().is_none());
 }
 

tests/multi-integer-store.rs

@@ -42,7 +42,7 @@ fn test_multi_integer_keys() {
                 .get(&writer, $key)
                 .expect("read")
                 .map(|result| result.expect("ok"))
-                .map(|(_, v)| v.expect("multi read"))
+                .map(|(_, v)| v)
                 .collect::<Vec<Value>>();
             assert_eq!(vals, vec![Value::Str("hello1"), Value::Str("hello2"), Value::Str("hello3")]);
             writer.commit().expect("committed");
@@ -52,7 +52,7 @@ fn test_multi_integer_keys() {
                 .get(&reader, $key)
                 .expect("read")
                 .map(|result| result.expect("ok"))
-                .map(|(_, v)| v.expect("multi read"))
+                .map(|(_, v)| v)
                 .collect::<Vec<Value>>();
             assert_eq!(vals, vec![Value::Str("hello1"), Value::Str("hello2"), Value::Str("hello3")]);
         }};

tests/test_txn.rs

@@ -99,7 +99,7 @@ where
         .expect("get iterator")
         .map(|id| {
             match id.expect("field") {
-                (_, Some(Value::U64(id))) => id,
+                (_, Value::U64(id)) => id,
                 _ => panic!("getting value in iter"),
             }
         })