misc cleanups

ssz-rs/src/error.rs

@@ -6,9 +6,9 @@ use crate::ser::SerializeError;
 // Top-level error to wrap all child errors in crate
 #[derive(Debug)]
 pub enum Error {
-    Serialize(/*#[from]*/ SerializeError),
-    Deserialize(/*#[from]*/ DeserializeError),
-    Merkleization(/*#[from]*/ MerkleizationError),
+    Serialize(SerializeError),
+    Deserialize(DeserializeError),
+    Merkleization(MerkleizationError),
 }
 
 impl From<SerializeError> for Error {

ssz-rs/src/lib.rs

@@ -39,11 +39,11 @@ mod lib {
         pub use std::*;
     }
 
-    pub use self::core::{any, cmp, iter, slice};
+    pub use self::core::{any, cmp, fmt, iter, slice};
 
     pub use self::cmp::Ordering;
     pub use self::core::array::TryFromSliceError;
-    pub use self::core::fmt::{self, Debug, Display, Formatter};
+    pub use self::core::fmt::{Debug, Display, Formatter};
     pub use self::core::ops::{Deref, DerefMut, Index, IndexMut};
     pub use self::core::slice::{IterMut, SliceIndex};
     pub use self::iter::Enumerate;

ssz-rs/src/list.rs

@@ -8,9 +8,9 @@ use crate::merkleization::{
 use crate::ser::{serialize_composite, Serialize, SerializeError};
 use crate::{SimpleSerialize, Sized};
 #[cfg(feature = "serde")]
-use core::marker::PhantomData;
-#[cfg(feature = "serde")]
 use serde::ser::SerializeSeq;
+#[cfg(feature = "serde")]
+use std::marker::PhantomData;
 
 /// A homogenous collection of a variable number of values.
 #[derive(Clone, Default)]
@@ -287,7 +287,7 @@ pub struct IterMut<'a, T, const N: usize>
 where
     T: SimpleSerialize,
 {
-    inner: Enumerate<crate::lib::IterMut<'a, T>>,
+    inner: Enumerate<slice::IterMut<'a, T>>,
     cache: &'a mut MerkleCache,
 }
 

ssz-rs/src/merkleization/mod.rs

@@ -19,9 +19,7 @@ pub trait Merkleized {
 
 #[derive(Debug)]
 pub enum MerkleizationError {
-    // #[error("failed to serialize value: {0}")]
-    SerializationError(/*#[from]*/ SerializeError),
-    // #[error("cannot merkleize data that exceeds the declared limit {0}")]
+    SerializationError(SerializeError),
     InputExceedsLimit(usize),
 }
 
@@ -33,15 +31,11 @@ impl From<SerializeError> for MerkleizationError {
 
 impl Display for MerkleizationError {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "the value could not be merkleized: ")?;
         match self {
             Self::SerializationError(err) => {
                 write!(f, "failed to serialize value: {err}")
             }
-            Self::InputExceedsLimit(size) => write!(
-                f,
-                "cannot merkleize data that exceeds the declared limit: {size}",
-            ),
+            Self::InputExceedsLimit(size) => write!(f, "data exceeds the declared limit {size}"),
         }
     }
 }

ssz-rs/src/ser.rs

@@ -8,12 +8,9 @@ const MAXIMUM_LENGTH: u64 = 2u64.pow((8 * BYTES_PER_LENGTH_OFFSET) as u32);
 
 #[derive(Debug)]
 pub enum SerializeError {
-    // #[error("the encoded length is {0} which exceeds the maximum length {MAXIMUM_LENGTH}")]
     MaximumEncodedLengthExceeded(usize),
-    // #[error("invalid instance: {0}")]
-    InvalidInstance(/*#[from]*/ InstanceError),
-    // #[error("invalid type: {0}")]
-    InvalidType(/*#[from]*/ TypeError),
+    InvalidInstance(InstanceError),
+    InvalidType(TypeError),
 }
 
 impl From<InstanceError> for SerializeError {

ssz-rs/src/vector.rs

@@ -7,9 +7,9 @@ use crate::merkleization::{
 use crate::ser::{serialize_composite, Serialize, SerializeError};
 use crate::{SimpleSerialize, Sized};
 #[cfg(feature = "serde")]
-use core::marker::PhantomData;
-#[cfg(feature = "serde")]
 use serde::ser::SerializeSeq;
+#[cfg(feature = "serde")]
+use std::marker::PhantomData;
 
 /// A homogenous collection of a fixed number of values.
 /// NOTE: a `Vector` of length `0` is illegal.