Added support for tuples with up to 8 values

src/de/impl_tuples.rs

@@ -0,0 +1,141 @@
+use super::{Decodable, Decode};
+use crate::error::DecodeError;
+
+impl<A> Decodable for (A,)
+where
+    A: Decodable,
+{
+    fn decode<_D: Decode>(mut decoder: _D) -> Result<Self, DecodeError> {
+        Ok((A::decode(&mut decoder)?,))
+    }
+}
+
+impl<A, B> Decodable for (A, B)
+where
+    A: Decodable,
+    B: Decodable,
+{
+    fn decode<_D: Decode>(mut decoder: _D) -> Result<Self, DecodeError> {
+        Ok((A::decode(&mut decoder)?, B::decode(&mut decoder)?))
+    }
+}
+
+impl<A, B, C> Decodable for (A, B, C)
+where
+    A: Decodable,
+    B: Decodable,
+    C: Decodable,
+{
+    fn decode<_D: Decode>(mut decoder: _D) -> Result<Self, DecodeError> {
+        Ok((
+            A::decode(&mut decoder)?,
+            B::decode(&mut decoder)?,
+            C::decode(&mut decoder)?,
+        ))
+    }
+}
+
+impl<A, B, C, D> Decodable for (A, B, C, D)
+where
+    A: Decodable,
+    B: Decodable,
+    C: Decodable,
+    D: Decodable,
+{
+    fn decode<_D: Decode>(mut decoder: _D) -> Result<Self, DecodeError> {
+        Ok((
+            A::decode(&mut decoder)?,
+            B::decode(&mut decoder)?,
+            C::decode(&mut decoder)?,
+            D::decode(&mut decoder)?,
+        ))
+    }
+}
+
+impl<A, B, C, D, E> Decodable for (A, B, C, D, E)
+where
+    A: Decodable,
+    B: Decodable,
+    C: Decodable,
+    D: Decodable,
+    E: Decodable,
+{
+    fn decode<_D: Decode>(mut decoder: _D) -> Result<Self, DecodeError> {
+        Ok((
+            A::decode(&mut decoder)?,
+            B::decode(&mut decoder)?,
+            C::decode(&mut decoder)?,
+            D::decode(&mut decoder)?,
+            E::decode(&mut decoder)?,
+        ))
+    }
+}
+
+impl<A, B, C, D, E, F> Decodable for (A, B, C, D, E, F)
+where
+    A: Decodable,
+    B: Decodable,
+    C: Decodable,
+    D: Decodable,
+    E: Decodable,
+    F: Decodable,
+{
+    fn decode<_D: Decode>(mut decoder: _D) -> Result<Self, DecodeError> {
+        Ok((
+            A::decode(&mut decoder)?,
+            B::decode(&mut decoder)?,
+            C::decode(&mut decoder)?,
+            D::decode(&mut decoder)?,
+            E::decode(&mut decoder)?,
+            F::decode(&mut decoder)?,
+        ))
+    }
+}
+
+impl<A, B, C, D, E, F, G> Decodable for (A, B, C, D, E, F, G)
+where
+    A: Decodable,
+    B: Decodable,
+    C: Decodable,
+    D: Decodable,
+    E: Decodable,
+    F: Decodable,
+    G: Decodable,
+{
+    fn decode<_D: Decode>(mut decoder: _D) -> Result<Self, DecodeError> {
+        Ok((
+            A::decode(&mut decoder)?,
+            B::decode(&mut decoder)?,
+            C::decode(&mut decoder)?,
+            D::decode(&mut decoder)?,
+            E::decode(&mut decoder)?,
+            F::decode(&mut decoder)?,
+            G::decode(&mut decoder)?,
+        ))
+    }
+}
+
+impl<A, B, C, D, E, F, G, H> Decodable for (A, B, C, D, E, F, G, H)
+where
+    A: Decodable,
+    B: Decodable,
+    C: Decodable,
+    D: Decodable,
+    E: Decodable,
+    F: Decodable,
+    G: Decodable,
+    H: Decodable,
+{
+    fn decode<_D: Decode>(mut decoder: _D) -> Result<Self, DecodeError> {
+        Ok((
+            A::decode(&mut decoder)?,
+            B::decode(&mut decoder)?,
+            C::decode(&mut decoder)?,
+            D::decode(&mut decoder)?,
+            E::decode(&mut decoder)?,
+            F::decode(&mut decoder)?,
+            G::decode(&mut decoder)?,
+            H::decode(&mut decoder)?,
+        ))
+    }
+}

src/de/mod.rs

@@ -3,6 +3,7 @@
 use crate::error::DecodeError;
 
 mod decoder;
+mod impl_tuples;
 mod impls;
 
 pub mod read;

src/enc/impl_tuples.rs

@@ -0,0 +1,138 @@
+use super::{Encode, Encodeable};
+use crate::error::EncodeError;
+
+impl<A> Encodeable for (A,)
+where
+    A: Encodeable,
+{
+    fn encode<_E: Encode>(&self, mut encoder: _E) -> Result<(), EncodeError> {
+        self.0.encode(&mut encoder)?;
+        Ok(())
+    }
+}
+
+impl<A, B> Encodeable for (A, B)
+where
+    A: Encodeable,
+    B: Encodeable,
+{
+    fn encode<_E: Encode>(&self, mut encoder: _E) -> Result<(), EncodeError> {
+        self.0.encode(&mut encoder)?;
+        self.1.encode(&mut encoder)?;
+        Ok(())
+    }
+}
+
+impl<A, B, C> Encodeable for (A, B, C)
+where
+    A: Encodeable,
+    B: Encodeable,
+    C: Encodeable,
+{
+    fn encode<_E: Encode>(&self, mut encoder: _E) -> Result<(), EncodeError> {
+        self.0.encode(&mut encoder)?;
+        self.1.encode(&mut encoder)?;
+        self.2.encode(&mut encoder)?;
+        Ok(())
+    }
+}
+
+impl<A, B, C, D> Encodeable for (A, B, C, D)
+where
+    A: Encodeable,
+    B: Encodeable,
+    C: Encodeable,
+    D: Encodeable,
+{
+    fn encode<_E: Encode>(&self, mut encoder: _E) -> Result<(), EncodeError> {
+        self.0.encode(&mut encoder)?;
+        self.1.encode(&mut encoder)?;
+        self.2.encode(&mut encoder)?;
+        self.3.encode(&mut encoder)?;
+        Ok(())
+    }
+}
+
+impl<A, B, C, D, E> Encodeable for (A, B, C, D, E)
+where
+    A: Encodeable,
+    B: Encodeable,
+    C: Encodeable,
+    D: Encodeable,
+    E: Encodeable,
+{
+    fn encode<_E: Encode>(&self, mut encoder: _E) -> Result<(), EncodeError> {
+        self.0.encode(&mut encoder)?;
+        self.1.encode(&mut encoder)?;
+        self.2.encode(&mut encoder)?;
+        self.3.encode(&mut encoder)?;
+        self.4.encode(&mut encoder)?;
+        Ok(())
+    }
+}
+
+impl<A, B, C, D, E, F> Encodeable for (A, B, C, D, E, F)
+where
+    A: Encodeable,
+    B: Encodeable,
+    C: Encodeable,
+    D: Encodeable,
+    E: Encodeable,
+    F: Encodeable,
+{
+    fn encode<_E: Encode>(&self, mut encoder: _E) -> Result<(), EncodeError> {
+        self.0.encode(&mut encoder)?;
+        self.1.encode(&mut encoder)?;
+        self.2.encode(&mut encoder)?;
+        self.3.encode(&mut encoder)?;
+        self.4.encode(&mut encoder)?;
+        self.5.encode(&mut encoder)?;
+        Ok(())
+    }
+}
+
+impl<A, B, C, D, E, F, G> Encodeable for (A, B, C, D, E, F, G)
+where
+    A: Encodeable,
+    B: Encodeable,
+    C: Encodeable,
+    D: Encodeable,
+    E: Encodeable,
+    F: Encodeable,
+    G: Encodeable,
+{
+    fn encode<_E: Encode>(&self, mut encoder: _E) -> Result<(), EncodeError> {
+        self.0.encode(&mut encoder)?;
+        self.1.encode(&mut encoder)?;
+        self.2.encode(&mut encoder)?;
+        self.3.encode(&mut encoder)?;
+        self.4.encode(&mut encoder)?;
+        self.5.encode(&mut encoder)?;
+        self.6.encode(&mut encoder)?;
+        Ok(())
+    }
+}
+
+impl<A, B, C, D, E, F, G, H> Encodeable for (A, B, C, D, E, F, G, H)
+where
+    A: Encodeable,
+    B: Encodeable,
+    C: Encodeable,
+    D: Encodeable,
+    E: Encodeable,
+    F: Encodeable,
+    G: Encodeable,
+    H: Encodeable,
+{
+    fn encode<_E: Encode>(&self, mut encoder: _E) -> Result<(), EncodeError> {
+        self.0.encode(&mut encoder)?;
+        self.1.encode(&mut encoder)?;
+        self.2.encode(&mut encoder)?;
+        self.3.encode(&mut encoder)?;
+        self.4.encode(&mut encoder)?;
+        self.5.encode(&mut encoder)?;
+        self.6.encode(&mut encoder)?;
+        self.7.encode(&mut encoder)?;
+        Ok(())
+    }
+}

src/enc/mod.rs

@@ -1,6 +1,7 @@
 //! Encoder-based structs and traits.
 
 mod encoder;
+mod impl_tuples;
 mod impls;
 
 use crate::error::EncodeError;

tests/basic_types.rs

@@ -58,6 +58,7 @@ where
 
 #[test]
 fn test_numbers() {
+    // integer types
     the_same(5u8);
     the_same(5u16);
     the_same(5u32);
@@ -75,13 +76,25 @@ fn test_numbers() {
     the_same(5.0f32);
     the_same(5.0f64);
 
+    // bool
     the_same(true);
     the_same(false);
 
+    // utf8 characters
     for char in "aÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö文".chars()
     {
         the_same(char);
     }
+
+    // tuples, up to 8
+    the_same((1u8,));
+    the_same((1u8, 2u8));
+    the_same((1u8, 2u8, 3u8));
+    the_same((1u8, 2u8, 3u8, 4u8));
+    the_same((1u8, 2u8, 3u8, 4u8, 5u8));
+    the_same((1u8, 2u8, 3u8, 4u8, 5u8, 6u8));
+    the_same((1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8));
+    the_same((1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8));
 }
 
 #[test]