more simplification

src/json.rs

@@ -925,7 +925,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
     }
 
     #[inline]
-    fn serialize_tuple_sep<
+    fn serialize_tuple_elt<
         T: Serializable
     >(&mut self, value: &T) -> IoResult<()> {
         if self.first {
@@ -948,7 +948,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
     }
 
     #[inline]
-    fn serialize_struct_sep<
+    fn serialize_struct_elt<
         T: Serializable
     >(&mut self, name: &str, value: &T) -> IoResult<()> {
         if self.first {
@@ -975,7 +975,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
     }
 
     #[inline]
-    fn serialize_enum_sep<
+    fn serialize_enum_elt<
         T: Serializable
     >(&mut self, value: &T) -> IoResult<()> {
         if self.first {
@@ -1184,7 +1184,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
     }
 
     #[inline]
-    fn serialize_tuple_sep<
+    fn serialize_tuple_elt<
         T: Serializable
     >(&mut self, value: &T) -> IoResult<()> {
         try!(self.serialize_sep());
@@ -1203,7 +1203,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
     }
 
     #[inline]
-    fn serialize_struct_sep<
+    fn serialize_struct_elt<
         T: Serializable
     >(&mut self, name: &str, value: &T) -> IoResult<()> {
         try!(self.serialize_sep());
@@ -1228,7 +1228,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
     }
 
     #[inline]
-    fn serialize_enum_sep<
+    fn serialize_enum_elt<
         T: Serializable
     >(&mut self, value: &T) -> IoResult<()> {
         try!(self.serialize_sep());
@@ -2234,11 +2234,14 @@ mod tests {
     }
 
     #[deriving(PartialEq, Show)]
+    #[deriving_serializable]
+    #[deriving_deserializable]
     enum Animal {
         Dog,
         Frog(String, Vec<int>)
     }
 
+    /*
     impl ser::Serializable for Animal {
         #[inline]
         fn serialize<
@@ -2285,6 +2288,7 @@ mod tests {
             }
         }
     }
+    */
 
     impl ToJson for Animal {
         fn to_json(&self) -> Json {
@@ -2308,12 +2312,15 @@ mod tests {
     }
 
     #[deriving(PartialEq, Show)]
+    #[deriving_serializable]
+    #[deriving_deserializable]
     struct Inner {
         a: (),
         b: uint,
         c: Vec<String>,
     }
 
+    /*
     impl ser::Serializable for Inner {
         #[inline]
         fn serialize<
@@ -2388,6 +2395,7 @@ mod tests {
             }
         }
     }
+    */
 
     impl ToJson for Inner {
         fn to_json(&self) -> Json {
@@ -2402,10 +2410,13 @@ mod tests {
     }
 
     #[deriving(PartialEq, Show)]
+    #[deriving_serializable]
+    #[deriving_deserializable]
     struct Outer {
         inner: Vec<Inner>,
     }
 
+    /*
     impl ser::Serializable for Outer {
         #[inline]
         fn serialize<
@@ -2465,6 +2476,7 @@ mod tests {
             }
         }
     }
+    */
 
     impl ToJson for Outer {
         fn to_json(&self) -> Json {

src/ser.rs

@@ -76,15 +76,15 @@ pub trait Serializer<E> {
     fn serialize_str(&mut self, v: &str) -> Result<(), E>;
 
     fn serialize_tuple_start(&mut self, len: uint) -> Result<(), E>;
-    fn serialize_tuple_sep<T: Serializable>(&mut self, v: &T) -> Result<(), E>;
+    fn serialize_tuple_elt<T: Serializable>(&mut self, v: &T) -> Result<(), E>;
     fn serialize_tuple_end(&mut self) -> Result<(), E>;
 
     fn serialize_struct_start(&mut self, name: &str, len: uint) -> Result<(), E>;
-    fn serialize_struct_sep<T: Serializable>(&mut self, name: &str, v: &T) -> Result<(), E>;
+    fn serialize_struct_elt<T: Serializable>(&mut self, name: &str, v: &T) -> Result<(), E>;
     fn serialize_struct_end(&mut self) -> Result<(), E>;
 
     fn serialize_enum_start(&mut self, name: &str, variant: &str, len: uint) -> Result<(), E>;
-    fn serialize_enum_sep<T: Serializable>(&mut self, v: &T) -> Result<(), E>;
+    fn serialize_enum_elt<T: Serializable>(&mut self, v: &T) -> Result<(), E>;
     fn serialize_enum_end(&mut self) -> Result<(), E>;
 
     fn serialize_option<T: Serializable>(&mut self, v: &Option<T>) -> Result<(), E>;
@@ -267,7 +267,7 @@ macro_rules! impl_serialize_tuple {
 
                 try!(s.serialize_tuple_start(len));
                 $(
-                    try!(s.serialize_tuple_sep($name));
+                    try!(s.serialize_tuple_elt($name));
                  )*
                 s.serialize_tuple_end()
             }
@@ -455,7 +455,7 @@ mod tests {
             self.serialize(TupleStart(len))
         }
 
-        fn serialize_tuple_sep<
+        fn serialize_tuple_elt<
             T: Serializable
         >(&mut self, value: &T) -> Result<(), Error> {
             try!(self.serialize(TupleSep));
@@ -470,7 +470,7 @@ mod tests {
             self.serialize(StructStart(name, len))
         }
 
-        fn serialize_struct_sep<
+        fn serialize_struct_elt<
             T: Serializable
         >(&mut self, name: &str, value: &T) -> Result<(), Error> {
             try!(self.serialize(StructSep(name)));
@@ -485,7 +485,7 @@ mod tests {
             self.serialize(EnumStart(name, variant, len))
         }
 
-        fn serialize_enum_sep<
+        fn serialize_enum_elt<
             T: Serializable
         >(&mut self, value: &T) -> Result<(), Error> {
             try!(self.serialize(EnumSep));