Remove length encoding (#102)

* Remove length encoding

* Improve bytes() test.

src/serde/reader.rs

@@ -336,29 +336,9 @@ impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer<R> {
     }
 
     fn deserialize_seq_fixed_size<V>(self,
-                            _: usize,
+                            len: usize,
                             visitor: V) -> DeserializeResult<V::Value>
         where V: serde::de::Visitor,
-    {
-        self.deserialize_seq(visitor)
-    }
-
-    fn deserialize_option<V>(self, visitor: V) -> DeserializeResult<V::Value>
-        where V: serde::de::Visitor,
-    {
-        let value: u8 = try!(serde::de::Deserialize::deserialize(&mut *self));
-        match value {
-            0 => visitor.visit_none(),
-            1 => visitor.visit_some(&mut *self),
-            _ => Err(DeserializeError::InvalidEncoding(InvalidEncoding {
-                desc: "invalid tag when decoding Option",
-                detail: Some(format!("Expected 0 or 1, got {}", value))
-            })),
-        }
-    }
-
-    fn deserialize_seq<V>(self, visitor: V) -> DeserializeResult<V::Value>
-        where V: serde::de::Visitor,
     {
         struct SeqVisitor<'a, R: Read + 'a> {
             deserializer: &'a mut Deserializer<R>,
@@ -381,9 +361,29 @@ impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer<R> {
             }
         }
 
+        visitor.visit_seq(SeqVisitor { deserializer: self, len: len })
+    }
+
+    fn deserialize_option<V>(self, visitor: V) -> DeserializeResult<V::Value>
+        where V: serde::de::Visitor,
+    {
+        let value: u8 = try!(serde::de::Deserialize::deserialize(&mut *self));
+        match value {
+            0 => visitor.visit_none(),
+            1 => visitor.visit_some(&mut *self),
+            _ => Err(DeserializeError::InvalidEncoding(InvalidEncoding {
+                desc: "invalid tag when decoding Option",
+                detail: Some(format!("Expected 0 or 1, got {}", value))
+            })),
+        }
+    }
+
+    fn deserialize_seq<V>(self, visitor: V) -> DeserializeResult<V::Value>
+        where V: serde::de::Visitor,
+    {
         let len = try!(serde::Deserialize::deserialize(&mut *self));
 
-        visitor.visit_seq(SeqVisitor { deserializer: self, len: len })
+        self.deserialize_seq_fixed_size(len, visitor)
     }
 
     fn deserialize_map<V>(self, visitor: V) -> DeserializeResult<V::Value>

src/serde/writer.rs

@@ -182,8 +182,8 @@ impl<'a, W: Write> serde::Serializer for &'a mut Serializer<W> {
         Ok(Compound {ser: self})
     }
 
-    fn serialize_seq_fixed_size(self, len: usize) -> SerializeResult<Self::SerializeSeq> {
+    fn serialize_seq_fixed_size(self, _len: usize) -> SerializeResult<Self::SerializeSeq> {
-        self.serialize_seq(Some(len))
+        Ok(Compound {ser: self})
     }
 
     fn serialize_tuple(self, _len: usize) -> SerializeResult<Self::SerializeTuple> {
@@ -378,8 +378,8 @@ impl<'a> serde::Serializer for &'a mut SizeChecker {
         Ok(SizeCompound {ser: self})
     }
 
-    fn serialize_seq_fixed_size(self, len: usize) -> SerializeResult<Self::SerializeSeq> {
+    fn serialize_seq_fixed_size(self, _len: usize) -> SerializeResult<Self::SerializeSeq> {
-        self.serialize_seq(Some(len))
+        Ok(SizeCompound {ser: self})
     }
 
     fn serialize_tuple(self, _len: usize) -> SerializeResult<Self::SerializeTuple> {

tests/test.rs

@@ -398,6 +398,6 @@ fn bytes() {
     let data = b"abc\0123";
     let s = serialize(&data, Infinite).unwrap();
     let s2 = serialize(&Bytes::new(data), Infinite).unwrap();
-    assert_eq!(s, s2);
+    assert_eq!(s[..], s2[8..]);
 }