Split Error into EncodeError and DecodeError

derive/src/derive_struct.rs

@@ -41,7 +41,7 @@ impl DeriveStruct {
 
         let result = quote! {
             impl bincode::enc::Encodeable for #name {
-                fn encode<E: bincode::enc::Encode>(&self, mut encoder: E) -> Result<(), bincode::error::Error> {
+                fn encode<E: bincode::enc::Encode>(&self, mut encoder: E) -> Result<(), bincode::error::EncodeError> {
                     #(#fields)*
                     Ok(())
                 }

src/de/impls.rs

@@ -1,8 +1,8 @@
 use super::{Decodable, Decode};
-use crate::error::Error;
+use crate::error::DecodeError;
 
 impl Decodable for u32 {
-    fn decode<D: Decode>(mut decoder: D) -> Result<Self, Error> {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
         decoder.decode_u32()
     }
 }

src/de/mod.rs

@@ -2,7 +2,7 @@ use core::marker::PhantomData;
 
 use crate::{
     config::{Config, Endian},
-    error::Error,
+    error::DecodeError,
 };
 use read::Reader;
 
@@ -10,11 +10,11 @@ mod impls;
 pub mod read;
 
 pub trait Decodable: Sized {
-    fn decode<D: Decode>(decoder: D) -> Result<Self, Error>;
+    fn decode<D: Decode>(decoder: D) -> Result<Self, DecodeError>;
 }
 
 pub trait Decode {
-    fn decode_u32(&mut self) -> Result<u32, Error>;
+    fn decode_u32(&mut self) -> Result<u32, DecodeError>;
 }
 
 pub struct Decoder<R, C: Config> {
@@ -32,7 +32,7 @@ impl<'de, R: Reader<'de>, C: Config> Decoder<R, C> {
 }
 
 impl<'a, 'de, R: Reader<'de>, C: Config> Decode for &'a mut Decoder<R, C> {
-    fn decode_u32(&mut self) -> Result<u32, Error> {
+    fn decode_u32(&mut self) -> Result<u32, DecodeError> {
         let mut bytes = [0u8; 4];
 
         self.reader.read(bytes.as_mut())?;

src/de/read.rs

@@ -1,8 +1,8 @@
-use crate::error::Error;
+use crate::error::DecodeError;
 
 pub trait Reader<'storage> {
-    fn read(&mut self, bytes: &mut [u8]) -> Result<(), Error>;
-    fn forward_read<F, R>(&mut self, length: usize, visitor: F) -> Result<R, Error>
+    fn read(&mut self, bytes: &mut [u8]) -> Result<(), DecodeError>;
+    fn forward_read<F, R>(&mut self, length: usize, visitor: F) -> Result<R, DecodeError>
     where
         F: Fn(&'storage [u8]) -> R;
 }
@@ -18,9 +18,9 @@ impl<'storage> SliceReader<'storage> {
     }
 
     #[inline(always)]
-    fn get_byte_slice(&mut self, length: usize) -> Result<&'storage [u8], Error> {
+    fn get_byte_slice(&mut self, length: usize) -> Result<&'storage [u8], DecodeError> {
         if length > self.slice.len() {
-            return Err(Error::UnexpectedEnd);
+            return Err(DecodeError::UnexpectedEnd);
         }
         let (read_slice, remaining) = self.slice.split_at(length);
         self.slice = remaining;
@@ -30,9 +30,9 @@ impl<'storage> SliceReader<'storage> {
 
 impl<'storage> Reader<'storage> for SliceReader<'storage> {
     #[inline(always)]
-    fn read(&mut self, bytes: &mut [u8]) -> Result<(), Error> {
+    fn read(&mut self, bytes: &mut [u8]) -> Result<(), DecodeError> {
         if bytes.len() > self.slice.len() {
-            return Err(Error::UnexpectedEnd);
+            return Err(DecodeError::UnexpectedEnd);
         }
         let (read_slice, remaining) = self.slice.split_at(bytes.len());
         bytes.copy_from_slice(read_slice);
@@ -42,7 +42,7 @@ impl<'storage> Reader<'storage> for SliceReader<'storage> {
     }
 
     #[inline(always)]
-    fn forward_read<F, R>(&mut self, length: usize, visitor: F) -> Result<R, Error>
+    fn forward_read<F, R>(&mut self, length: usize, visitor: F) -> Result<R, DecodeError>
     where
         F: Fn(&'storage [u8]) -> R,
     {

src/enc/encoder.rs

@@ -2,7 +2,7 @@ use super::write::Writer;
 use super::Encode;
 use crate::{
     config::{Config, Endian, IntEncoding},
-    error::Error,
+    error::EncodeError,
 };
 use core::marker::PhantomData;
 
@@ -25,14 +25,14 @@ impl<W: Writer, C: Config> Encoder<W, C> {
 }
 
 impl<'a, W: Writer, C: Config> Encode for &'a mut Encoder<W, C> {
-    fn encode_u8(&mut self, val: u8) -> Result<(), Error> {
+    fn encode_u8(&mut self, val: u8) -> Result<(), EncodeError> {
         self.writer.write(&[val])
     }
 
-    fn encode_u16(&mut self, val: u16) -> Result<(), Error> {
+    fn encode_u16(&mut self, val: u16) -> Result<(), EncodeError> {
         match C::INT_ENCODING {
             IntEncoding::Variable => {
-                crate::varint_encoding::varint_encode_u16(&mut self.writer, C::ENDIAN, val)
+                crate::varint::varint_encode_u16(&mut self.writer, C::ENDIAN, val)
             }
             IntEncoding::Fixed => match C::ENDIAN {
                 Endian::Big => self.writer.write(&val.to_be_bytes()),
@@ -41,10 +41,10 @@ impl<'a, W: Writer, C: Config> Encode for &'a mut Encoder<W, C> {
         }
     }
 
-    fn encode_u32(&mut self, val: u32) -> Result<(), Error> {
+    fn encode_u32(&mut self, val: u32) -> Result<(), EncodeError> {
         match C::INT_ENCODING {
             IntEncoding::Variable => {
-                crate::varint_encoding::varint_encode_u32(&mut self.writer, C::ENDIAN, val)
+                crate::varint::varint_encode_u32(&mut self.writer, C::ENDIAN, val)
             }
             IntEncoding::Fixed => match C::ENDIAN {
                 Endian::Big => self.writer.write(&val.to_be_bytes()),
@@ -53,10 +53,10 @@ impl<'a, W: Writer, C: Config> Encode for &'a mut Encoder<W, C> {
         }
     }
 
-    fn encode_u64(&mut self, val: u64) -> Result<(), Error> {
+    fn encode_u64(&mut self, val: u64) -> Result<(), EncodeError> {
         match C::INT_ENCODING {
             IntEncoding::Variable => {
-                crate::varint_encoding::varint_encode_u64(&mut self.writer, C::ENDIAN, val)
+                crate::varint::varint_encode_u64(&mut self.writer, C::ENDIAN, val)
             }
             IntEncoding::Fixed => match C::ENDIAN {
                 Endian::Big => self.writer.write(&val.to_be_bytes()),
@@ -65,10 +65,10 @@ impl<'a, W: Writer, C: Config> Encode for &'a mut Encoder<W, C> {
         }
     }
 
-    fn encode_u128(&mut self, val: u128) -> Result<(), Error> {
+    fn encode_u128(&mut self, val: u128) -> Result<(), EncodeError> {
         match C::INT_ENCODING {
             IntEncoding::Variable => {
-                crate::varint_encoding::varint_encode_u128(&mut self.writer, C::ENDIAN, val)
+                crate::varint::varint_encode_u128(&mut self.writer, C::ENDIAN, val)
             }
             IntEncoding::Fixed => match C::ENDIAN {
                 Endian::Big => self.writer.write(&val.to_be_bytes()),
@@ -77,10 +77,10 @@ impl<'a, W: Writer, C: Config> Encode for &'a mut Encoder<W, C> {
         }
     }
 
-    fn encode_usize(&mut self, val: usize) -> Result<(), Error> {
+    fn encode_usize(&mut self, val: usize) -> Result<(), EncodeError> {
         match C::INT_ENCODING {
             IntEncoding::Variable => {
-                crate::varint_encoding::varint_encode_usize(&mut self.writer, C::ENDIAN, val)
+                crate::varint::varint_encode_usize(&mut self.writer, C::ENDIAN, val)
             }
             IntEncoding::Fixed => match C::ENDIAN {
                 Endian::Big => self.writer.write(&val.to_be_bytes()),
@@ -89,14 +89,14 @@ impl<'a, W: Writer, C: Config> Encode for &'a mut Encoder<W, C> {
         }
     }
 
-    fn encode_i8(&mut self, val: i8) -> Result<(), Error> {
+    fn encode_i8(&mut self, val: i8) -> Result<(), EncodeError> {
         self.writer.write(&[val as u8])
     }
 
-    fn encode_i16(&mut self, val: i16) -> Result<(), Error> {
+    fn encode_i16(&mut self, val: i16) -> Result<(), EncodeError> {
         match C::INT_ENCODING {
             IntEncoding::Variable => {
-                crate::varint_encoding::varint_encode_i16(&mut self.writer, C::ENDIAN, val)
+                crate::varint::varint_encode_i16(&mut self.writer, C::ENDIAN, val)
             }
             IntEncoding::Fixed => match C::ENDIAN {
                 Endian::Big => self.writer.write(&val.to_be_bytes()),
@@ -105,10 +105,10 @@ impl<'a, W: Writer, C: Config> Encode for &'a mut Encoder<W, C> {
         }
     }
 
-    fn encode_i32(&mut self, val: i32) -> Result<(), Error> {
+    fn encode_i32(&mut self, val: i32) -> Result<(), EncodeError> {
         match C::INT_ENCODING {
             IntEncoding::Variable => {
-                crate::varint_encoding::varint_encode_i32(&mut self.writer, C::ENDIAN, val)
+                crate::varint::varint_encode_i32(&mut self.writer, C::ENDIAN, val)
             }
             IntEncoding::Fixed => match C::ENDIAN {
                 Endian::Big => self.writer.write(&val.to_be_bytes()),
@@ -117,10 +117,10 @@ impl<'a, W: Writer, C: Config> Encode for &'a mut Encoder<W, C> {
         }
     }
 
-    fn encode_i64(&mut self, val: i64) -> Result<(), Error> {
+    fn encode_i64(&mut self, val: i64) -> Result<(), EncodeError> {
         match C::INT_ENCODING {
             IntEncoding::Variable => {
-                crate::varint_encoding::varint_encode_i64(&mut self.writer, C::ENDIAN, val)
+                crate::varint::varint_encode_i64(&mut self.writer, C::ENDIAN, val)
             }
             IntEncoding::Fixed => match C::ENDIAN {
                 Endian::Big => self.writer.write(&val.to_be_bytes()),
@@ -129,10 +129,10 @@ impl<'a, W: Writer, C: Config> Encode for &'a mut Encoder<W, C> {
         }
     }
 
-    fn encode_i128(&mut self, val: i128) -> Result<(), Error> {
+    fn encode_i128(&mut self, val: i128) -> Result<(), EncodeError> {
         match C::INT_ENCODING {
             IntEncoding::Variable => {
-                crate::varint_encoding::varint_encode_i128(&mut self.writer, C::ENDIAN, val)
+                crate::varint::varint_encode_i128(&mut self.writer, C::ENDIAN, val)
             }
             IntEncoding::Fixed => match C::ENDIAN {
                 Endian::Big => self.writer.write(&val.to_be_bytes()),
@@ -141,10 +141,10 @@ impl<'a, W: Writer, C: Config> Encode for &'a mut Encoder<W, C> {
         }
     }
 
-    fn encode_isize(&mut self, val: isize) -> Result<(), Error> {
+    fn encode_isize(&mut self, val: isize) -> Result<(), EncodeError> {
         match C::INT_ENCODING {
             IntEncoding::Variable => {
-                crate::varint_encoding::varint_encode_isize(&mut self.writer, C::ENDIAN, val)
+                crate::varint::varint_encode_isize(&mut self.writer, C::ENDIAN, val)
             }
             IntEncoding::Fixed => match C::ENDIAN {
                 Endian::Big => self.writer.write(&val.to_be_bytes()),
@@ -153,7 +153,7 @@ impl<'a, W: Writer, C: Config> Encode for &'a mut Encoder<W, C> {
         }
     }
 
-    fn encode_f32(&mut self, val: f32) -> Result<(), Error> {
+    fn encode_f32(&mut self, val: f32) -> Result<(), EncodeError> {
         match C::INT_ENCODING {
             IntEncoding::Variable => unimplemented!(), // crate::int_encoding::varint_encode_f32(&mut self.writer, C::ENDIAN, val),
             IntEncoding::Fixed => match C::ENDIAN {
@@ -163,7 +163,7 @@ impl<'a, W: Writer, C: Config> Encode for &'a mut Encoder<W, C> {
         }
     }
 
-    fn encode_f64(&mut self, val: f64) -> Result<(), Error> {
+    fn encode_f64(&mut self, val: f64) -> Result<(), EncodeError> {
         match C::INT_ENCODING {
             IntEncoding::Variable => unimplemented!(), // crate::int_encoding::varint_encode_f64(&mut self.writer, C::ENDIAN, val),
             IntEncoding::Fixed => match C::ENDIAN {
@@ -173,7 +173,7 @@ impl<'a, W: Writer, C: Config> Encode for &'a mut Encoder<W, C> {
         }
     }
 
-    fn encode_slice(&mut self, val: &[u8]) -> Result<(), Error> {
+    fn encode_slice(&mut self, val: &[u8]) -> Result<(), EncodeError> {
         // TODO: Should this be swapped if we're big or little endian?
         self.writer.write(val)
     }

src/enc/impls.rs

@@ -1,92 +1,92 @@
 use super::{Encode, Encodeable};
-use crate::error::Error;
+use crate::error::EncodeError;
 
 impl Encodeable for u8 {
-    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), Error> {
+    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), EncodeError> {
         encoder.encode_u8(*self)
     }
 }
 
 impl Encodeable for u16 {
-    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), Error> {
+    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), EncodeError> {
         encoder.encode_u16(*self)
     }
 }
 
 impl Encodeable for u32 {
-    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), Error> {
+    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), EncodeError> {
         encoder.encode_u32(*self)
     }
 }
 
 impl Encodeable for u64 {
-    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), Error> {
+    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), EncodeError> {
         encoder.encode_u64(*self)
     }
 }
 
 impl Encodeable for u128 {
-    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), Error> {
+    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), EncodeError> {
         encoder.encode_u128(*self)
     }
 }
 
 impl Encodeable for usize {
-    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), Error> {
+    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), EncodeError> {
         encoder.encode_usize(*self)
     }
 }
 
 impl Encodeable for i8 {
-    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), Error> {
+    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), EncodeError> {
         encoder.encode_i8(*self)
     }
 }
 
 impl Encodeable for i16 {
-    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), Error> {
+    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), EncodeError> {
         encoder.encode_i16(*self)
     }
 }
 
 impl Encodeable for i32 {
-    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), Error> {
+    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), EncodeError> {
         encoder.encode_i32(*self)
     }
 }
 
 impl Encodeable for i64 {
-    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), Error> {
+    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), EncodeError> {
         encoder.encode_i64(*self)
     }
 }
 
 impl Encodeable for i128 {
-    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), Error> {
+    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), EncodeError> {
         encoder.encode_i128(*self)
     }
 }
 
 impl Encodeable for isize {
-    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), Error> {
+    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), EncodeError> {
         encoder.encode_isize(*self)
     }
 }
 
 impl Encodeable for f32 {
-    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), Error> {
+    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), EncodeError> {
         encoder.encode_f32(*self)
     }
 }
 
 impl Encodeable for f64 {
-    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), Error> {
+    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), EncodeError> {
         encoder.encode_f64(*self)
     }
 }
 
 impl Encodeable for &'_ [u8] {
-    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), Error> {
+    fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), EncodeError> {
         encoder.encode_slice(*self)
     }
 }
@@ -95,51 +95,51 @@ impl<'a, T> Encode for &'a mut T
 where
     T: Encode,
 {
-    fn encode_u8(&mut self, val: u8) -> Result<(), Error> {
+    fn encode_u8(&mut self, val: u8) -> Result<(), EncodeError> {
         T::encode_u8(self, val)
     }
-    fn encode_u16(&mut self, val: u16) -> Result<(), Error> {
+    fn encode_u16(&mut self, val: u16) -> Result<(), EncodeError> {
         T::encode_u16(self, val)
     }
-    fn encode_u32(&mut self, val: u32) -> Result<(), Error> {
+    fn encode_u32(&mut self, val: u32) -> Result<(), EncodeError> {
         T::encode_u32(self, val)
     }
-    fn encode_u64(&mut self, val: u64) -> Result<(), Error> {
+    fn encode_u64(&mut self, val: u64) -> Result<(), EncodeError> {
         T::encode_u64(self, val)
     }
-    fn encode_u128(&mut self, val: u128) -> Result<(), Error> {
+    fn encode_u128(&mut self, val: u128) -> Result<(), EncodeError> {
         T::encode_u128(self, val)
     }
-    fn encode_usize(&mut self, val: usize) -> Result<(), Error> {
+    fn encode_usize(&mut self, val: usize) -> Result<(), EncodeError> {
         T::encode_usize(self, val)
     }
 
-    fn encode_i8(&mut self, val: i8) -> Result<(), Error> {
+    fn encode_i8(&mut self, val: i8) -> Result<(), EncodeError> {
         T::encode_i8(self, val)
     }
-    fn encode_i16(&mut self, val: i16) -> Result<(), Error> {
+    fn encode_i16(&mut self, val: i16) -> Result<(), EncodeError> {
         T::encode_i16(self, val)
     }
-    fn encode_i32(&mut self, val: i32) -> Result<(), Error> {
+    fn encode_i32(&mut self, val: i32) -> Result<(), EncodeError> {
         T::encode_i32(self, val)
     }
-    fn encode_i64(&mut self, val: i64) -> Result<(), Error> {
+    fn encode_i64(&mut self, val: i64) -> Result<(), EncodeError> {
         T::encode_i64(self, val)
     }
-    fn encode_i128(&mut self, val: i128) -> Result<(), Error> {
+    fn encode_i128(&mut self, val: i128) -> Result<(), EncodeError> {
         T::encode_i128(self, val)
     }
-    fn encode_isize(&mut self, val: isize) -> Result<(), Error> {
+    fn encode_isize(&mut self, val: isize) -> Result<(), EncodeError> {
         T::encode_isize(self, val)
     }
 
-    fn encode_f32(&mut self, val: f32) -> Result<(), Error> {
+    fn encode_f32(&mut self, val: f32) -> Result<(), EncodeError> {
         T::encode_f32(self, val)
     }
-    fn encode_f64(&mut self, val: f64) -> Result<(), Error> {
+    fn encode_f64(&mut self, val: f64) -> Result<(), EncodeError> {
         T::encode_f64(self, val)
     }
-    fn encode_slice(&mut self, val: &[u8]) -> Result<(), Error> {
+    fn encode_slice(&mut self, val: &[u8]) -> Result<(), EncodeError> {
         T::encode_slice(self, val)
     }
 }

src/enc/mod.rs

@@ -1,32 +1,32 @@
 mod encoder;
 mod impls;
 
-use crate::error::Error;
+use crate::error::EncodeError;
 
 pub mod write;
 
 pub use self::encoder::Encoder;
 
 pub trait Encodeable {
-    fn encode<E: Encode>(&self, encoder: E) -> Result<(), Error>;
+    fn encode<E: Encode>(&self, encoder: E) -> Result<(), EncodeError>;
 }
 
 pub trait Encode {
-    fn encode_u8(&mut self, val: u8) -> Result<(), Error>;
-    fn encode_u16(&mut self, val: u16) -> Result<(), Error>;
-    fn encode_u32(&mut self, val: u32) -> Result<(), Error>;
-    fn encode_u64(&mut self, val: u64) -> Result<(), Error>;
-    fn encode_u128(&mut self, val: u128) -> Result<(), Error>;
-    fn encode_usize(&mut self, val: usize) -> Result<(), Error>;
+    fn encode_u8(&mut self, val: u8) -> Result<(), EncodeError>;
+    fn encode_u16(&mut self, val: u16) -> Result<(), EncodeError>;
+    fn encode_u32(&mut self, val: u32) -> Result<(), EncodeError>;
+    fn encode_u64(&mut self, val: u64) -> Result<(), EncodeError>;
+    fn encode_u128(&mut self, val: u128) -> Result<(), EncodeError>;
+    fn encode_usize(&mut self, val: usize) -> Result<(), EncodeError>;
 
-    fn encode_i8(&mut self, val: i8) -> Result<(), Error>;
-    fn encode_i16(&mut self, val: i16) -> Result<(), Error>;
-    fn encode_i32(&mut self, val: i32) -> Result<(), Error>;
-    fn encode_i64(&mut self, val: i64) -> Result<(), Error>;
-    fn encode_i128(&mut self, val: i128) -> Result<(), Error>;
-    fn encode_isize(&mut self, val: isize) -> Result<(), Error>;
+    fn encode_i8(&mut self, val: i8) -> Result<(), EncodeError>;
+    fn encode_i16(&mut self, val: i16) -> Result<(), EncodeError>;
+    fn encode_i32(&mut self, val: i32) -> Result<(), EncodeError>;
+    fn encode_i64(&mut self, val: i64) -> Result<(), EncodeError>;
+    fn encode_i128(&mut self, val: i128) -> Result<(), EncodeError>;
+    fn encode_isize(&mut self, val: isize) -> Result<(), EncodeError>;
 
-    fn encode_f32(&mut self, val: f32) -> Result<(), Error>;
-    fn encode_f64(&mut self, val: f64) -> Result<(), Error>;
-    fn encode_slice(&mut self, val: &[u8]) -> Result<(), Error>;
+    fn encode_f32(&mut self, val: f32) -> Result<(), EncodeError>;
+    fn encode_f64(&mut self, val: f64) -> Result<(), EncodeError>;
+    fn encode_slice(&mut self, val: &[u8]) -> Result<(), EncodeError>;
 }

src/enc/write.rs

@@ -1,7 +1,7 @@
-use crate::error::Error;
+use crate::error::EncodeError;
 
 pub trait Writer {
-    fn write(&mut self, bytes: &[u8]) -> Result<(), Error>;
+    fn write(&mut self, bytes: &[u8]) -> Result<(), EncodeError>;
 }
 
 pub struct SliceWriter<'storage> {
@@ -23,10 +23,10 @@ impl<'storage> SliceWriter<'storage> {
 }
 
 impl<'storage> Writer for SliceWriter<'storage> {
-    fn write(&mut self, bytes: &[u8]) -> Result<(), Error> {
+    fn write(&mut self, bytes: &[u8]) -> Result<(), EncodeError> {
         let remaining = &mut self.slice[self.idx..];
         if bytes.len() > remaining.len() {
-            return Err(Error::UnexpectedEnd);
+            return Err(EncodeError::UnexpectedEnd);
         }
         self.idx += bytes.len();
         let write_slice = &mut remaining[..bytes.len()];

src/error.rs

@@ -1,6 +1,29 @@
 #[non_exhaustive]
 #[derive(Debug)]
-pub enum Error {
+pub enum EncodeError {
     InvalidIntEncoding,
     UnexpectedEnd,
 }
+
+#[non_exhaustive]
+#[derive(Debug)]
+pub enum DecodeError {
+    UnexpectedEnd,
+    /// Invalid type was found. The decoder tried to read type `expected`, but found type `found` instead.
+    InvalidIntegerType {
+        /// The type that was being read from the reader
+        expected: IntegerType,
+        /// The type that was encoded in the data
+        found: IntegerType,
+    },
+}
+
+#[non_exhaustive]
+#[derive(Debug)]
+pub enum IntegerType {
+    U16,
+    U32,
+    U64,
+    U128,
+    USize,
+}

src/lib.rs

@@ -22,19 +22,19 @@ pub mod error;
 
 pub use bincode_derive::{Decodable, Encodable};
 
-pub(crate) mod varint_encoding;
+pub(crate) mod varint;
 
 pub fn encode_into_slice<E: enc::Encodeable>(
     val: E,
     dst: &mut [u8],
-) -> Result<usize, error::Error> {
+) -> Result<usize, error::EncodeError> {
     let writer = enc::write::SliceWriter::new(dst);
     let mut encoder = enc::Encoder::<_, config::Default>::new(writer);
     val.encode(&mut encoder)?;
     Ok(encoder.into_writer().bytes_written())
 }
 
-pub fn decode<D: de::Decodable>(src: &mut [u8]) -> Result<D, error::Error> {
+pub fn decode<D: de::Decodable>(src: &mut [u8]) -> Result<D, error::DecodeError> {
     let reader = de::read::SliceReader::new(src);
     let mut decoder = de::Decoder::<_, config::Default>::new(reader);
     D::decode(&mut decoder)

src/varint/encode_signed.rs

@@ -1,7 +1,11 @@
 use super::{varint_encode_u128, varint_encode_u16, varint_encode_u32, varint_encode_u64};
-use crate::{config::Endian, enc::write::Writer, error::Error};
+use crate::{config::Endian, enc::write::Writer, error::EncodeError};
 
-pub fn varint_encode_i16<W: Writer>(writer: &mut W, endian: Endian, val: i16) -> Result<(), Error> {
+pub fn varint_encode_i16<W: Writer>(
+    writer: &mut W,
+    endian: Endian,
+    val: i16,
+) -> Result<(), EncodeError> {
     varint_encode_u16(
         writer,
         endian,
@@ -16,7 +20,11 @@ pub fn varint_encode_i16<W: Writer>(writer: &mut W, endian: Endian, val: i16) ->
     )
 }
 
-pub fn varint_encode_i32<W: Writer>(writer: &mut W, endian: Endian, val: i32) -> Result<(), Error> {
+pub fn varint_encode_i32<W: Writer>(
+    writer: &mut W,
+    endian: Endian,
+    val: i32,
+) -> Result<(), EncodeError> {
     varint_encode_u32(
         writer,
         endian,
@@ -31,7 +39,11 @@ pub fn varint_encode_i32<W: Writer>(writer: &mut W, endian: Endian, val: i32) ->
     )
 }
 
-pub fn varint_encode_i64<W: Writer>(writer: &mut W, endian: Endian, val: i64) -> Result<(), Error> {
+pub fn varint_encode_i64<W: Writer>(
+    writer: &mut W,
+    endian: Endian,
+    val: i64,
+) -> Result<(), EncodeError> {
     varint_encode_u64(
         writer,
         endian,
@@ -50,7 +62,7 @@ pub fn varint_encode_i128<W: Writer>(
     writer: &mut W,
     endian: Endian,
     val: i128,
-) -> Result<(), Error> {
+) -> Result<(), EncodeError> {
     varint_encode_u128(
         writer,
         endian,
@@ -69,7 +81,7 @@ pub fn varint_encode_isize<W: Writer>(
     writer: &mut W,
     endian: Endian,
     val: isize,
-) -> Result<(), Error> {
+) -> Result<(), EncodeError> {
     // isize is being encoded as a i64
     varint_encode_i64(writer, endian, val as i64)
 }

src/varint/encode_unsigned.rs

@@ -1,7 +1,11 @@
 use super::{SINGLE_BYTE_MAX, U128_BYTE, U16_BYTE, U32_BYTE, U64_BYTE};
-use crate::{config::Endian, enc::write::Writer, error::Error};
+use crate::{config::Endian, enc::write::Writer, error::EncodeError};
 
-pub fn varint_encode_u16<W: Writer>(writer: &mut W, endian: Endian, val: u16) -> Result<(), Error> {
+pub fn varint_encode_u16<W: Writer>(
+    writer: &mut W,
+    endian: Endian,
+    val: u16,
+) -> Result<(), EncodeError> {
     if val <= SINGLE_BYTE_MAX as _ {
         writer.write(&[val as u8])
     } else {
@@ -13,7 +17,11 @@ pub fn varint_encode_u16<W: Writer>(writer: &mut W, endian: Endian, val: u16) ->
     }
 }
 
-pub fn varint_encode_u32<W: Writer>(writer: &mut W, endian: Endian, val: u32) -> Result<(), Error> {
+pub fn varint_encode_u32<W: Writer>(
+    writer: &mut W,
+    endian: Endian,
+    val: u32,
+) -> Result<(), EncodeError> {
     if val <= SINGLE_BYTE_MAX as _ {
         writer.write(&[val as u8])
     } else if val <= u16::MAX as _ {
@@ -31,7 +39,11 @@ pub fn varint_encode_u32<W: Writer>(writer: &mut W, endian: Endian, val: u32) ->
     }
 }
 
-pub fn varint_encode_u64<W: Writer>(writer: &mut W, endian: Endian, val: u64) -> Result<(), Error> {
+pub fn varint_encode_u64<W: Writer>(
+    writer: &mut W,
+    endian: Endian,
+    val: u64,
+) -> Result<(), EncodeError> {
     if val <= SINGLE_BYTE_MAX as _ {
         writer.write(&[val as u8])
     } else if val <= u16::MAX as _ {
@@ -59,7 +71,7 @@ pub fn varint_encode_u128<W: Writer>(
     writer: &mut W,
     endian: Endian,
     val: u128,
-) -> Result<(), Error> {
+) -> Result<(), EncodeError> {
     if val <= SINGLE_BYTE_MAX as _ {
         writer.write(&[val as u8])
     } else if val <= u16::MAX as _ {
@@ -93,7 +105,7 @@ pub fn varint_encode_usize<W: Writer>(
     writer: &mut W,
     endian: Endian,
     val: usize,
-) -> Result<(), Error> {
+) -> Result<(), EncodeError> {
     // usize is being encoded as a u64
     varint_encode_u64(writer, endian, val as u64)
 }

src/varint/mod.rs

@@ -1,11 +1,11 @@
-mod signed;
-mod unsigned;
+mod encode_signed;
+mod encode_unsigned;
 
-pub use self::signed::{
+pub use self::encode_signed::{
     varint_encode_i128, varint_encode_i16, varint_encode_i32, varint_encode_i64,
     varint_encode_isize,
 };
-pub use self::unsigned::{
+pub use self::encode_unsigned::{
     varint_encode_u128, varint_encode_u16, varint_encode_u32, varint_encode_u64,
     varint_encode_usize,
 };