Fixed return type of load_mem; clippy happy

Author: vigna

CHANGELOG.md

@@ -1,13 +1,17 @@
 # Change Log
 
-## [0.6.2] - 2024-07-19
+## [0.6.2] - 2025-02-07
+
+### Improved
+
+* Added missing implementation of `TypeHash`, `ReprHash`, `MaxSizeOf`,
+  `SerializeInner`, `DeserializeInner` for `Range`, `RangeFrom`, `RangeFull`,
+  `RangeInclusive`, `RangeTo`, `RangeToInclusive`, `Bound`, `ControlFlow`.
 
 ### Fixed
 
-* Added missing implementation of `TypeHash`, `ReprHash`, `MaxSizeOf`, 
-  `SerializeInner`, `DeserializeInner` for:
-  `Range`, `RangeFrom`, `RangeFull`, `RangeInclusive`, `RangeTo`, 
-  `RangeToInclusive`, `Bound`, `ControlFlow`.
+* The return type of `Deserialize::load_full` is how an `anyhow::Result`,
+  analogously to the other `load` functions.
 
 ## [0.6.1] - 2024-06-03
 

README.md

@@ -60,44 +60,45 @@ These are the main limitations you should be aware of before choosing to use
   tree.
 
 - While we provide procedural macros that implement serialization and
-deserialization, they require that your type is written and used in a specific
-way; in particular, the fields you want to ε-copy must be type parameters
-implementing [`DeserializeInner`], to which a [deserialized type] is associated.
-For example, we provide implementations for `Vec<T>`/`Box<[T]>`, where `T` is
-zero-copy, or `String`/`Box<str>`, which have associated deserialized type
-`&[T]` or `&str`, respectively. Vectors and boxed slices of types that are not
-zero-copy will be deserialized recursively in memory instead.
+  deserialization, they require that your type is written and used in a specific
+  way; in particular, the fields you want to ε-copy must be type parameters
+  implementing [`DeserializeInner`], to which a [deserialized type] is
+  associated. For example, we provide implementations for `Vec<T>`/`Box<[T]>`,
+  where `T` is zero-copy, or `String`/`Box<str>`, which have associated
+  deserialized type `&[T]` or `&str`, respectively. Vectors and boxed slices of
+  types that are not zero-copy will be deserialized recursively in memory
+  instead.
 
 - After deserialization of a type `T`, you will obtain an associated
-deserialized type [`DeserType<'_,T>`], which will usually reference the
-underlying serialized support (e.g., a memory-mapped region); hence the need for
-a lifetime. If you need to store the deserialized structure in a field of a new
-structure you will need to couple permanently the deserialized structure with
-its serialized support, which is obtained by putting it in a [`MemCase`] using
-the convenience methods [`Deserialize::load_mem`], [`Deserialize::load_mmap`],
-and [`Deserialize::mmap`]. A [`MemCase`] will deref to its contained type, so it
-can be used transparently as long as fields and methods are concerned, but if
-your original type is `T` the field of the new structure will have to be of type
-`MemCase<DeserType<'static, T>>`, not `T`.
+  deserialized type [`DeserType<'_,T>`], which will usually reference the
+  underlying serialized support (e.g., a memory-mapped region); hence the need for
+  a lifetime. If you need to store the deserialized structure in a field of a new
+  structure you will need to couple permanently the deserialized structure with
+  its serialized support, which is obtained by putting it in a [`MemCase`] using
+  the convenience methods [`Deserialize::load_mem`], [`Deserialize::load_mmap`],
+  and [`Deserialize::mmap`]. A [`MemCase`] will deref to its contained type, so it
+  can be used transparently as long as fields and methods are concerned, but if
+  your original type is `T` the field of the new structure will have to be of type
+  `MemCase<DeserType<'static, T>>`, not `T`.
 
 ## Pros
 
 - Almost instant deserialization with minimal allocation provided that you
-designed your type following the ε-serde guidelines or that you use standard
-types.
+  designed your type following the ε-serde guidelines or that you use standard
+  types.
 
 - The structure you get by deserialization is the same structure you serialized,
-except that type parameters will be replaced by their associated deserialization
-type (e.g., vectors will become references to slices). This is not the
-case with [rkiv], which requires you to reimplement all methods on the
-deserialized type.
+  except that type parameters will be replaced by their associated deserialization
+  type (e.g., vectors will become references to slices). This is not the
+  case with [rkiv], which requires you to reimplement all methods on the
+  deserialized type.
 
 - The structure you get by deserialization has exactly the same performance as
-the structure you serialized. This is not the case with [zerovec] or [rkiv].
+  the structure you serialized. This is not the case with [zerovec] or [rkiv].
 
 - You can deserialize from read-only supports, as all dynamic information
-generated at deserialization time is stored in newly allocated memory. This is
-not the case with [Abomonation].
+  generated at deserialization time is stored in newly allocated memory. This is
+  not the case with [Abomonation].
 
 ## Example: Zero copy of standard types
 
@@ -298,20 +299,20 @@ s.store(&file);
 let b = std::fs::read(&file)?;
 
 // The type of t will be inferred--it is shown here only for clarity
-let t: DeserType<'_, MyStruct<Vec<isize>>> = 
+let t: MyStruct<&[isize]> = 
     <MyStruct<Vec<isize>>>::deserialize_eps(b.as_ref())?;
 
 assert_eq!(s.id, t.id);
 assert_eq!(s.data, Vec::from(t.data));
 
 // This is a traditional deserialization instead
 let t: MyStruct<Vec<isize>> = 
-    <MyStruct::<Vec<isize>>>::load_full(&file)?;
+    <MyStruct<Vec<isize>>>::load_full(&file)?;
 assert_eq!(s, t);
 
 // In this case we map the data structure into memory
-let u: MemCase<DeserType<'static, MyStruct<Vec<isize>>>> = 
-    <MyStruct::<Vec<isize>>>::mmap(&file, Flags::empty())?;
+let u: MemCase<MyStruct<&[isize]>> = 
+    <MyStruct<Vec<isize>>>::mmap(&file, Flags::empty())?;
 assert_eq!(s.id, u.id);
 assert_eq!(s.data, u.data.as_ref());
 #     Ok(())
@@ -486,7 +487,7 @@ Every type serializable with ε-serde has two features that are in principle
 orthogonal, but that in practice often condition one another:
 
 - the type has an *associated deserialization type*, which is the type you
-obtain upon deserialization;
+  obtain upon deserialization;
 - the type can be either [`ZeroCopy`] or [`DeepCopy`]; it can also be neither.
 
 There is no constraint on the associated deserialization type: it can be
@@ -513,11 +514,11 @@ types are always fully deserialized*. There are two reasons behind this
 non-orthogonal choice:
 
 - primitive types occupy so little space that deserializing them as a reference
-is not efficient;
+  is not efficient;
 - if a type parameter `T` is a primitive type, writing generic code for
-`AsRef<T>` is really not nice;
+  `AsRef<T>` is really not nice;
 - deserializing primitive types to a reference would require further padding to
-align them.
+  align them.
 
 Since this is true only of primitive types, when deserializing a 1-tuple
 containing a primitive type one obtains a reference (and indeed this workaround

epserde/examples/array.rs

@@ -9,7 +9,6 @@ use epserde::prelude::*;
 use maligned::A16;
 
 /// Example of zero-copy deserialization of an array.
-
 fn main() {
     // Create a vector to serialize
 

epserde/examples/onetuple_zero_copy.rs

@@ -31,7 +31,7 @@ fn main() {
     println!();
 
     // Do an ε-copy deserialization (which will be zero-copy deserialization)
-    let eps = <(usize,)>::deserialize_eps(&cursor.as_bytes()).unwrap();
+    let eps = <(usize,)>::deserialize_eps(cursor.as_bytes()).unwrap();
     println!(
         "ε-copy deserialization type: {}",
         std::any::type_name::<<(usize,) as DeserializeInner>::DeserType<'_>>(),

epserde/src/deser/mod.rs

@@ -53,11 +53,11 @@ pub trait Deserialize: TypeHash + ReprHash + DeserializeInner {
     /// ε-copy deserialize a structure of this type from the given backend.
     fn deserialize_eps(backend: &'_ [u8]) -> Result<Self::DeserType<'_>>;
 
-    /// Commodity method to fully deserialize from a file.
-    fn load_full(path: impl AsRef<Path>) -> Result<Self> {
+    /// Convenience method to fully deserialize from a file.
+    fn load_full(path: impl AsRef<Path>) -> anyhow::Result<Self> {
         let file = std::fs::File::open(path).map_err(Error::FileOpenError)?;
         let mut buf_reader = BufReader::new(file);
-        Self::deserialize_full(&mut buf_reader)
+        Self::deserialize_full(&mut buf_reader).map_err(|e| e.into())
     }
 
     /// Load a file into heap-allocated memory and ε-deserialize a data structure from it,

epserde/src/deser/reader_with_pos.rs

@@ -28,15 +28,15 @@ impl<'a, F: ReadNoStd> ReaderWithPos<'a, F> {
     }
 }
 
-impl<'a, F: ReadNoStd> ReadNoStd for ReaderWithPos<'a, F> {
+impl<F: ReadNoStd> ReadNoStd for ReaderWithPos<'_, F> {
     fn read_exact(&mut self, buf: &mut [u8]) -> deser::Result<()> {
         self.backend.read_exact(buf)?;
         self.pos += buf.len();
         Ok(())
     }
 }
 
-impl<'a, F: ReadNoStd> ReadWithPos for ReaderWithPos<'a, F> {
+impl<F: ReadNoStd> ReadWithPos for ReaderWithPos<'_, F> {
     fn pos(&self) -> usize {
         self.pos
     }

epserde/src/deser/slice_with_pos.rs

@@ -31,7 +31,7 @@ impl<'a> SliceWithPos<'a> {
     }
 }
 
-impl<'a> ReadNoStd for SliceWithPos<'a> {
+impl ReadNoStd for SliceWithPos<'_> {
     fn read_exact(&mut self, buf: &mut [u8]) -> deser::Result<()> {
         let len = buf.len();
         if len > self.data.len() {
@@ -44,7 +44,7 @@ impl<'a> ReadNoStd for SliceWithPos<'a> {
     }
 }
 
-impl<'a> ReadWithPos for SliceWithPos<'a> {
+impl ReadWithPos for SliceWithPos<'_> {
     fn pos(&self) -> usize {
         self.pos
     }

epserde/src/impls/array.rs

@@ -99,8 +99,8 @@ impl<T: ZeroCopy + DeserializeInner + 'static, const N: usize> DeserializeHelper
             Ok(res.assume_init())
         }
     }
-    #[inline(always)]
 
+    #[inline(always)]
     fn _deserialize_eps_inner_impl<'a>(
         backend: &mut SliceWithPos<'a>,
     ) -> deser::Result<<Self as DeserializeInner>::DeserType<'a>> {

epserde/src/impls/stdlib.rs

@@ -153,7 +153,7 @@ impl<Idx: DeserializeInner> DeserializeInner for core::ops::RangeInclusive<Idx>
         let end = Idx::_deserialize_eps_inner(backend)?;
         let exhausted = bool::_deserialize_full_inner(backend)?;
         assert!(!exhausted, "cannot deserialize an exhausted range");
-        return Ok(start..=end);
+        Ok(start..=end)
     }
 }
 

epserde/src/ser/mod.rs

@@ -63,7 +63,7 @@ pub trait Serialize: TypeHash + ReprHash {
     /// Serialize the type using the given [`WriteWithNames`].
     fn serialize_on_field_write(&self, backend: &mut impl WriteWithNames) -> Result<()>;
 
-    /// Commodity method to serialize to a file.
+    /// Convenience method to serialize to a file.
     fn store(&self, path: impl AsRef<Path>) -> Result<()> {
         let file = std::fs::File::create(path).map_err(Error::FileOpenError)?;
         let mut buf_writer = BufWriter::new(file);