Unabbreviated method naming

serde/src/ser/impls.rs

@@ -169,9 +169,9 @@ impl<T> Serialize for [T]
     {
         let mut seq = try!(serializer.serialize_seq(Some(self.len())));
         for e in self {
-            try!(seq.serialize_elem(e));
+            try!(seq.serialize_element(e));
         }
-        seq.serialize_end()
+        seq.end()
     }
 }
 
@@ -186,9 +186,9 @@ macro_rules! array_impls {
             {
                 let mut seq = try!(serializer.serialize_seq_fixed_size($len));
                 for e in self {
-                    try!(seq.serialize_elem(e));
+                    try!(seq.serialize_element(e));
                 }
-                seq.serialize_end()
+                seq.end()
             }
         }
     }
@@ -249,9 +249,9 @@ impl<'a, I> Serialize for Iterator<I>
         };
         let mut seq = try!(serializer.serialize_seq(size));
         for e in iter {
-            try!(seq.serialize_elem(e));
+            try!(seq.serialize_element(e));
         }
-        seq.serialize_end()
+        seq.end()
     }
 }
 
@@ -265,9 +265,9 @@ macro_rules! serialize_seq {
         {
             let mut seq = try!(serializer.serialize_seq(Some(self.len())));
             for e in self {
-                try!(seq.serialize_elem(e));
+                try!(seq.serialize_element(e));
             }
-            seq.serialize_end()
+            seq.end()
         }
     }
 }
@@ -334,9 +334,9 @@ impl<A> Serialize for ops::Range<A>
         let len = iter::Step::steps_between(&self.start, &self.end, &A::one());
         let mut seq = try!(serializer.serialize_seq(len));
         for e in self.clone() {
-            try!(seq.serialize_elem(e));
+            try!(seq.serialize_element(e));
         }
-        seq.serialize_end()
+        seq.end()
     }
 }
 
@@ -369,9 +369,9 @@ macro_rules! tuple_impls {
                 {
                     let mut tuple = try!(serializer.serialize_tuple($len));
                     $(
-                        try!(tuple.serialize_elem(&self.$idx));
+                        try!(tuple.serialize_element(&self.$idx));
                     )+
-                    tuple.serialize_end()
+                    tuple.end()
                 }
             }
         )+
@@ -562,7 +562,7 @@ macro_rules! serialize_map {
                 try!(map.serialize_key(k));
                 try!(map.serialize_value(v));
             }
-            map.serialize_end()
+            map.end()
         }
     }
 }
@@ -682,7 +682,7 @@ impl Serialize for Duration {
         let mut state = try!(serializer.serialize_struct("Duration", 2));
         try!(state.serialize_field("secs", self.as_secs()));
         try!(state.serialize_field("nanos", self.subsec_nanos()));
-        state.serialize_end()
+        state.end()
     }
 }
 

serde/src/ser/mod.rs

@@ -183,9 +183,9 @@ pub trait Serializer {
     /// ```rust
     /// let mut seq = self.serialize_seq(Some(value.len()))?;
     /// for b in value {
-    ///     seq.serialize_elem(b)?;
+    ///     seq.serialize_element(b)?;
     /// }
-    /// seq.serialize_end()
+    /// seq.end()
     /// ```
     fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok, Self::Error>;
 
@@ -324,10 +324,10 @@ pub trait SerializeSeq {
     type Error: Error;
 
     /// Serializes a sequence element.
-    fn serialize_elem<T: Serialize>(&mut self, value: T) -> Result<(), Self::Error>;
+    fn serialize_element<T: Serialize>(&mut self, value: T) -> Result<(), Self::Error>;
 
     /// Finishes serializing a sequence.
-    fn serialize_end(self) -> Result<Self::Ok, Self::Error>;
+    fn end(self) -> Result<Self::Ok, Self::Error>;
 }
 
 /// Returned from `Serializer::serialize_tuple`.
@@ -340,10 +340,10 @@ pub trait SerializeTuple {
     type Error: Error;
 
     /// Serializes a tuple element.
-    fn serialize_elem<T: Serialize>(&mut self, value: T) -> Result<(), Self::Error>;
+    fn serialize_element<T: Serialize>(&mut self, value: T) -> Result<(), Self::Error>;
 
     /// Finishes serializing a tuple.
-    fn serialize_end(self) -> Result<Self::Ok, Self::Error>;
+    fn end(self) -> Result<Self::Ok, Self::Error>;
 }
 
 /// Returned from `Serializer::serialize_tuple_struct`.
@@ -356,10 +356,10 @@ pub trait SerializeTupleStruct {
     type Error: Error;
 
     /// Serializes a tuple struct element.
-    fn serialize_elem<T: Serialize>(&mut self, value: T) -> Result<(), Self::Error>;
+    fn serialize_field<T: Serialize>(&mut self, value: T) -> Result<(), Self::Error>;
 
     /// Finishes serializing a tuple struct.
-    fn serialize_end(self) -> Result<Self::Ok, Self::Error>;
+    fn end(self) -> Result<Self::Ok, Self::Error>;
 }
 
 /// Returned from `Serializer::serialize_tuple_variant`.
@@ -372,10 +372,10 @@ pub trait SerializeTupleVariant {
     type Error: Error;
 
     /// Serializes a tuple variant element.
-    fn serialize_elem<T: Serialize>(&mut self, value: T) -> Result<(), Self::Error>;
+    fn serialize_field<T: Serialize>(&mut self, value: T) -> Result<(), Self::Error>;
 
     /// Finishes serializing a tuple variant.
-    fn serialize_end(self) -> Result<Self::Ok, Self::Error>;
+    fn end(self) -> Result<Self::Ok, Self::Error>;
 }
 
 /// Returned from `Serializer::serialize_map`.
@@ -394,7 +394,7 @@ pub trait SerializeMap {
     fn serialize_value<T: Serialize>(&mut self, value: T) -> Result<(), Self::Error>;
 
     /// Finishes serializing a map.
-    fn serialize_end(self) -> Result<Self::Ok, Self::Error>;
+    fn end(self) -> Result<Self::Ok, Self::Error>;
 }
 
 /// Returned from `Serializer::serialize_struct`.
@@ -410,7 +410,7 @@ pub trait SerializeStruct {
     fn serialize_field<V: Serialize>(&mut self, key: &'static str, value: V) -> Result<(), Self::Error>;
 
     /// Finishes serializing a struct.
-    fn serialize_end(self) -> Result<Self::Ok, Self::Error>;
+    fn end(self) -> Result<Self::Ok, Self::Error>;
 }
 
 /// Returned from `Serializer::serialize_struct_variant`.
@@ -426,7 +426,7 @@ pub trait SerializeStructVariant {
     fn serialize_field<V: Serialize>(&mut self, key: &'static str, value: V) -> Result<(), Self::Error>;
 
     /// Finishes serializing a struct variant.
-    fn serialize_end(self) -> Result<Self::Ok, Self::Error>;
+    fn end(self) -> Result<Self::Ok, Self::Error>;
 }
 
 /// A wrapper type for iterators that implements `Serialize` for iterators whose items implement