Rename Serialize::visit to Serialize::serialize

src/json/ser.rs

@@ -183,7 +183,7 @@ impl<W> ser::Serializer for Serializer<W>
     fn visit_some<V>(&mut self, value: V) -> io::Result<()>
         where V: ser::Serialize
     {
-        value.visit(self)
+        value.serialize(self)
     }
 
     #[inline]
@@ -236,7 +236,7 @@ impl<W> ser::Serializer for Serializer<W>
     {
         try!(self.serialize_sep(first));
 
-        value.visit(self)
+        value.serialize(self)
     }
 
     #[inline]
@@ -272,9 +272,9 @@ impl<W> ser::Serializer for Serializer<W>
               V: ser::Serialize,
     {
         try!(self.serialize_sep(first));
-        try!(key.visit(self));
+        try!(key.serialize(self));
         try!(self.serialize_colon());
-        value.visit(self)
+        value.serialize(self)
     }
 }
 
@@ -356,7 +356,7 @@ pub fn to_writer<W, T>(writer: &mut W, value: &T) -> io::Result<()>
           T: ser::Serialize,
 {
     let mut ser = Serializer::new(writer);
-    try!(value.visit(&mut ser));
+    try!(value.serialize(&mut ser));
     Ok(())
 }
 
@@ -367,7 +367,7 @@ pub fn to_writer_pretty<W, T>(writer: &mut W, value: &T) -> io::Result<()>
           T: ser::Serialize,
 {
     let mut ser = Serializer::new_pretty(writer);
-    try!(value.visit(&mut ser));
+    try!(value.serialize(&mut ser));
     Ok(())
 }
 

src/json/value.rs

@@ -21,7 +21,7 @@ pub enum Value {
 
 impl ser::Serialize for Value {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: ser::Serializer,
     {
         match *self {
@@ -30,8 +30,8 @@ impl ser::Serialize for Value {
             Value::I64(v) => serializer.visit_i64(v),
             Value::F64(v) => serializer.visit_f64(v),
             Value::String(ref v) => serializer.visit_str(&v),
-            Value::Array(ref v) => v.visit(serializer),
-            Value::Object(ref v) => v.visit(serializer),
+            Value::Array(ref v) => v.serialize(serializer),
+            Value::Object(ref v) => v.serialize(serializer),
         }
     }
 }
@@ -210,7 +210,7 @@ impl ser::Serializer for Serializer {
     fn visit_some<V>(&mut self, value: V) -> Result<(), ()>
         where V: ser::Serialize,
     {
-        value.visit(self)
+        value.serialize(self)
     }
 
     #[inline]
@@ -278,7 +278,7 @@ impl ser::Serializer for Serializer {
     fn visit_seq_elt<T>(&mut self, _first: bool, value: T) -> Result<(), ()>
         where T: ser::Serialize,
     {
-        try!(value.visit(self));
+        try!(value.serialize(self));
 
         let value = match self.state.pop().unwrap() {
             State::Value(value) => value,
@@ -338,14 +338,14 @@ impl ser::Serializer for Serializer {
         where K: ser::Serialize,
               V: ser::Serialize,
     {
-        try!(key.visit(self));
+        try!(key.serialize(self));
 
         let key = match self.state.pop().unwrap() {
             State::Value(Value::String(value)) => value,
             state => panic!("expected key, found {:?}", state),
         };
 
-        try!(value.visit(self));
+        try!(value.serialize(self));
 
         let value = match self.state.pop().unwrap() {
             State::Value(value) => value,
@@ -577,7 +577,7 @@ pub fn to_value<T>(value: &T) -> Value
     where T: ser::Serialize
 {
     let mut ser = Serializer::new();
-    value.visit(&mut ser).ok().unwrap();
+    value.serialize(&mut ser).ok().unwrap();
     ser.unwrap()
 }
 

src/ser.rs

@@ -9,7 +9,7 @@ use std::sync::Arc;
 ///////////////////////////////////////////////////////////////////////////////
 
 pub trait Serialize {
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer;
 }
 
@@ -185,7 +185,7 @@ macro_rules! impl_visit {
     ($ty:ty, $method:ident) => {
         impl Serialize for $ty {
             #[inline]
-            fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+            fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
                 where S: Serializer,
             {
                 serializer.$method(*self)
@@ -213,7 +213,7 @@ impl_visit!(char, visit_char);
 
 impl<'a> Serialize for &'a str {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
         serializer.visit_str(*self)
@@ -222,10 +222,10 @@ impl<'a> Serialize for &'a str {
 
 impl Serialize for String {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        (&self[..]).visit(serializer)
+        (&self[..]).serialize(serializer)
     }
 }
 
@@ -233,7 +233,7 @@ impl Serialize for String {
 
 impl<T> Serialize for Option<T> where T: Serialize {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
         match *self {
@@ -294,7 +294,7 @@ impl<'a, T> Serialize for &'a [T]
     where T: Serialize,
 {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
         serializer.visit_seq(SeqIteratorVisitor::new(self.iter()))
@@ -303,16 +303,16 @@ impl<'a, T> Serialize for &'a [T]
 
 impl<T> Serialize for Vec<T> where T: Serialize {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        (&self[..]).visit(serializer)
+        (&self[..]).serialize(serializer)
     }
 }
 
 impl<T> Serialize for BTreeSet<T> where T: Serialize {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
         serializer.visit_seq(SeqIteratorVisitor::new(self.iter()))
@@ -324,7 +324,7 @@ impl<T, H> Serialize for HashSet<T, H>
           H: HashState,
 {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
         serializer.visit_seq(SeqIteratorVisitor::new(self.iter()))
@@ -335,7 +335,7 @@ impl<T, H> Serialize for HashSet<T, H>
 
 impl Serialize for () {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
         serializer.visit_unit()
@@ -403,7 +403,7 @@ macro_rules! tuple_impls {
                 where $($T: Serialize),+
             {
                 #[inline]
-                fn visit<S: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error> {
+                fn serialize<S: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error> {
                     serializer.visit_seq($TupleVisitor::new(self))
                 }
             }
@@ -569,7 +569,7 @@ impl<K, V> Serialize for BTreeMap<K, V>
           V: Serialize,
 {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
         serializer.visit_map(MapIteratorVisitor::new(self.iter()))
@@ -582,7 +582,7 @@ impl<K, V, H> Serialize for HashMap<K, V, H>
           H: HashState,
 {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
         serializer.visit_map(MapIteratorVisitor::new(self.iter()))
@@ -593,63 +593,63 @@ impl<K, V, H> Serialize for HashMap<K, V, H>
 
 impl<'a, T> Serialize for &'a T where T: Serialize {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        (**self).visit(serializer)
+        (**self).serialize(serializer)
     }
 }
 
 impl<'a, T> Serialize for &'a mut T where T: Serialize {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        (**self).visit(serializer)
+        (**self).serialize(serializer)
     }
 }
 
 impl<T> Serialize for Box<T> where T: Serialize {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        (**self).visit(serializer)
+        (**self).serialize(serializer)
     }
 }
 
 impl<T> Serialize for Rc<T> where T: Serialize, {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        (**self).visit(serializer)
+        (**self).serialize(serializer)
     }
 }
 
 impl<T> Serialize for Arc<T> where T: Serialize, {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        (**self).visit(serializer)
+        (**self).serialize(serializer)
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 impl Serialize for path::Path {
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        self.to_str().unwrap().visit(serializer)
+        self.to_str().unwrap().serialize(serializer)
     }
 }
 
 impl Serialize for path::PathBuf {
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        self.to_str().unwrap().visit(serializer)
+        self.to_str().unwrap().serialize(serializer)
     }
 }