Update to serde 0.9.0 (fixes #7)

Cargo.toml

@@ -8,6 +8,9 @@ documentation = "https://docs.rs/serde_urlencoded"
 description = "`x-www-form-urlencoded` meets Serde"
 keywords = ["serde", "serialization", "urlencoded"]
 
+[lib]
+test = false
+
 [dependencies]
-serde = "0.8.7"
+serde = "0.9.2"
 url = "1.0.0"

src/de.rs

@@ -4,7 +4,6 @@ use serde::de;
 
 pub use serde::de::value::Error;
 use serde::de::value::MapDeserializer;
-use std::borrow::Cow;
 use url::form_urlencoded::Parse as UrlEncodedParse;
 use url::form_urlencoded::parse;
 
@@ -24,7 +23,7 @@ use url::form_urlencoded::parse;
 ///     Ok(meal));
 /// ```
 pub fn from_bytes<T: de::Deserialize>(input: &[u8]) -> Result<T, Error> {
-    T::deserialize(&mut Deserializer::new(parse(input)))
+    T::deserialize(Deserializer::new(parse(input)))
 }
 
 /// Deserializes a `application/x-wwww-url-encoded` value from a `&str`.
@@ -56,61 +55,52 @@ pub fn from_str<T: de::Deserialize>(input: &str) -> Result<T, Error> {
 /// * Everything else but `deserialize_seq` and `deserialize_seq_fixed_size`
 ///   defers to `deserialize`.
 pub struct Deserializer<'a> {
-    inner: MapDeserializer<UrlEncodedParse<'a>,
+    inner: MapDeserializer<UrlEncodedParse<'a>, Error>,
-                           Cow<'a, str>,
-                           Cow<'a, str>,
-                           Error>,
 }
 
 impl<'a> Deserializer<'a> {
     /// Returns a new `Deserializer`.
     pub fn new(parser: UrlEncodedParse<'a>) -> Self {
-        Deserializer { inner: MapDeserializer::unbounded(parser) }
+        Deserializer { inner: MapDeserializer::new(parser) }
     }
 }
 
 impl<'a> de::Deserializer for Deserializer<'a> {
     type Error = Error;
 
-    fn deserialize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
         self.deserialize_map(visitor)
     }
 
-    fn deserialize_map<V>(&mut self,
+    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-                          mut visitor: V)
-                          -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
-        visitor.visit_map(&mut self.inner)
+        visitor.visit_map(self.inner)
     }
 
-    fn deserialize_seq<V>(&mut self,
+    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-                          mut visitor: V)
-                          -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
-        visitor.visit_seq(&mut self.inner)
+        visitor.visit_seq(self.inner)
     }
 
-    fn deserialize_seq_fixed_size<V>(&mut self,
+    fn deserialize_seq_fixed_size<V>(self,
                                      _len: usize,
-                                     mut visitor: V)
+                                     visitor: V)
                                      -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
-        visitor.visit_seq(&mut self.inner)
+        visitor.visit_seq(self.inner)
     }
 
     forward_to_deserialize! {
         bool
-        usize
         u8
         u16
         u32
         u64
-        isize
         i8
         i16
         i32
@@ -123,6 +113,7 @@ impl<'a> de::Deserializer for Deserializer<'a> {
         unit
         option
         bytes
+        byte_buf
         unit_struct
         newtype_struct
         tuple_struct

src/ser/key.rs

@@ -1,302 +1,80 @@
-
 use ser::Error;
-use serde::{Serialize, Serializer};
+use ser::part::Sink;
+use serde::Serialize;
 use std::borrow::Cow;
-use std::str;
+use std::ops::Deref;
 
-pub struct MapKeySerializer<'key>(&'key mut Option<Cow<'static, str>>);
+pub enum Key<'key> {
-
+    Static(&'static str),
-impl<'key> MapKeySerializer<'key> {
+    Dynamic(Cow<'key, str>),
-    pub fn new(output: &'key mut Option<Cow<'static, str>>) -> Self {
-        MapKeySerializer(output)
-    }
-
-    fn set_key<T>(&mut self, key: T) -> Result<(), Error>
-        where T: Into<Cow<'static, str>>,
-    {
-        *self.0 = Some(key.into());
-        Ok(())
-    }
 }
 
-impl<'key> Serializer for MapKeySerializer<'key> {
+impl<'key> Deref for Key<'key> {
-    type Error = Error;
+    type Target = str;
-    type SeqState = ();
-    type TupleState = ();
-    type TupleStructState = ();
-    type TupleVariantState = ();
-    type MapState = ();
-    type StructState = ();
-    type StructVariantState = ();
 
-    fn serialize_bool(&mut self, _v: bool) -> Result<(), Error> {
+    fn deref(&self) -> &str {
-        Err(Error::unsupported_key())
+        match *self {
-    }
+            Key::Static(key) => key,
-
+            Key::Dynamic(ref key) => key,
-    fn serialize_isize(&mut self, v: isize) -> Result<(), Error> {
-        self.set_key(v.to_string())
-    }
-
-    fn serialize_i8(&mut self, v: i8) -> Result<(), Error> {
-        self.set_key(v.to_string())
-    }
-
-    fn serialize_i16(&mut self, v: i16) -> Result<(), Error> {
-        self.set_key(v.to_string())
-    }
-
-    fn serialize_i32(&mut self, v: i32) -> Result<(), Error> {
-        self.set_key(v.to_string())
-    }
-
-    fn serialize_i64(&mut self, v: i64) -> Result<(), Error> {
-        self.set_key(v.to_string())
-    }
-
-    fn serialize_usize(&mut self, v: usize) -> Result<(), Error> {
-        self.set_key(v.to_string())
-    }
-
-    fn serialize_u8(&mut self, v: u8) -> Result<(), Error> {
-        self.set_key(v.to_string())
-    }
-
-    fn serialize_u16(&mut self, v: u16) -> Result<(), Error> {
-        self.set_key(v.to_string())
-    }
-
-    fn serialize_u32(&mut self, v: u32) -> Result<(), Error> {
-        self.set_key(v.to_string())
-    }
-
-    fn serialize_u64(&mut self, v: u64) -> Result<(), Error> {
-        self.set_key(v.to_string())
-    }
-
-    fn serialize_f32(&mut self, v: f32) -> Result<(), Error> {
-        self.set_key(v.to_string())
-    }
-
-    fn serialize_f64(&mut self, v: f64) -> Result<(), Error> {
-        self.set_key(v.to_string())
-    }
-
-    fn serialize_char(&mut self, v: char) -> Result<(), Error> {
-        self.set_key(v.to_string())
-    }
-
-    fn serialize_str(&mut self, value: &str) -> Result<(), Error> {
-        self.set_key(String::from(value))
-    }
-
-    fn serialize_bytes(&mut self, value: &[u8]) -> Result<(), Error> {
-        match str::from_utf8(value) {
-            Ok(value) => self.set_key(String::from(value)),
-            Err(err) => Err(Error::Utf8(err)),
         }
     }
+}
 
-    fn serialize_unit(&mut self) -> Result<(), Error> {
+impl<'key> From<Key<'key>> for Cow<'static, str> {
-        Err(Error::unsupported_key())
+    fn from(key: Key<'key>) -> Self {
-    }
+        match key {
-
+            Key::Static(key) => key.into(),
-    fn serialize_unit_struct(&mut self,
+            Key::Dynamic(key) => key.into_owned().into(),
-                             name: &'static str)
+        }
-                             -> Result<(), Error> {
-        self.set_key(name)
-    }
-
-    fn serialize_unit_variant(&mut self,
-                              _name: &'static str,
-                              _variant_index: usize,
-                              variant: &'static str)
-                              -> Result<(), Error> {
-        self.set_key(variant)
-    }
-
-    fn serialize_newtype_struct<T>(&mut self,
-                                   _name: &'static str,
-                                   value: T)
-                                   -> Result<(), Error>
-        where T: Serialize,
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_newtype_variant<T>(&mut self,
-                                    _name: &'static str,
-                                    _variant_index: usize,
-                                    _variant: &'static str,
-                                    _value: T)
-                                    -> Result<(), Error>
-        where T: Serialize,
-    {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_none(&mut self) -> Result<(), Error> {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_some<T>(&mut self, _value: T) -> Result<(), Error>
-        where T: Serialize,
-    {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_seq(&mut self, _len: Option<usize>) -> Result<(), Error> {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_seq_elt<T>(&mut self,
-                            _state: &mut (),
-                            _value: T)
-                            -> Result<(), Error>
-        where T: Serialize,
-    {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_seq_end(&mut self, _state: ()) -> Result<(), Error> {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_seq_fixed_size(&mut self, _size: usize) -> Result<(), Error> {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_tuple(&mut self, _len: usize) -> Result<(), Error> {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_tuple_elt<T>(&mut self,
-                              _state: &mut (),
-                              _value: T)
-                              -> Result<(), Error>
-        where T: Serialize,
-    {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_tuple_end(&mut self, _state: ()) -> Result<(), Error> {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_tuple_struct(&mut self,
-                              _name: &'static str,
-                              _len: usize)
-                              -> Result<(), Error> {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_tuple_struct_elt<T>(&mut self,
-                                     _state: &mut (),
-                                     _value: T)
-                                     -> Result<(), Error>
-        where T: Serialize,
-    {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_tuple_struct_end(&mut self, _state: ()) -> Result<(), Error> {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_tuple_variant(&mut self,
-                               _name: &'static str,
-                               _variant_index: usize,
-                               _variant: &'static str,
-                               _len: usize)
-                               -> Result<(), Error> {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_tuple_variant_elt<T>(&mut self,
-                                      _state: &mut (),
-                                      _value: T)
-                                      -> Result<(), Error>
-        where T: Serialize,
-    {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_tuple_variant_end(&mut self, _state: ()) -> Result<(), Error> {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_map(&mut self, _len: Option<usize>) -> Result<(), Error> {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_map_key<T>(&mut self,
-                            _state: &mut (),
-                            _key: T)
-                            -> Result<(), Error>
-        where T: Serialize,
-    {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_map_value<T>(&mut self,
-                              _state: &mut (),
-                              _value: T)
-                              -> Result<(), Error>
-        where T: Serialize,
-    {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_map_end(&mut self, _state: ()) -> Result<(), Error> {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_struct(&mut self,
-                        _name: &'static str,
-                        _len: usize)
-                        -> Result<(), Error> {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_struct_elt<T>(&mut self,
-                               _state: &mut (),
-                               _key: &'static str,
-                               _value: T)
-                               -> Result<(), Error>
-        where T: Serialize,
-    {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_struct_end(&mut self, _state: ()) -> Result<(), Error> {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_struct_variant(&mut self,
-                                _name: &'static str,
-                                _variant_index: usize,
-                                _variant: &'static str,
-                                _len: usize)
-                                -> Result<(), Error> {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_struct_variant_elt<T>(&mut self,
-                                       _state: &mut (),
-                                       _key: &'static str,
-                                       _value: T)
-                                       -> Result<(), Error> {
-        Err(Error::unsupported_key())
-    }
-
-    fn serialize_struct_variant_end(&mut self,
-                                    _state: ())
-                                    -> Result<(), Error> {
-        Err(Error::unsupported_key())
     }
 }
 
-impl Error {
+pub struct KeySink<End> {
-    fn unsupported_key() -> Self {
+    end: End,
+}
+
+impl<End, Ok> KeySink<End>
+    where End: for<'key> FnOnce(Key<'key>) -> Result<Ok, Error>
+{
+    pub fn new(end: End) -> Self {
+        KeySink { end: end }
+    }
+}
+
+impl<End, Ok> Sink for KeySink<End>
+    where End: for<'key> FnOnce(Key<'key>) -> Result<Ok, Error>
+{
+    type Ok = Ok;
+
+    fn serialize_bool(self, _value: bool) -> Result<Ok, Error> {
+        Err(self.unsupported())
+    }
+
+    fn serialize_static_str(self,
+                            value: &'static str)
+                            -> Result<Ok, Error> {
+        (self.end)(Key::Static(value))
+    }
+
+    fn serialize_str(self, value: &str) -> Result<Ok, Error> {
+        (self.end)(Key::Dynamic(value.into()))
+    }
+
+    fn serialize_string(self, value: String) -> Result<Ok, Error> {
+        (self.end)(Key::Dynamic(value.into()))
+    }
+
+    fn serialize_none(self) -> Result<Ok, Error> {
+        Err(self.unsupported())
+    }
+
+    fn serialize_some<T: ?Sized + Serialize>(self,
+                                             _value: &T)
+                                             -> Result<Ok, Error> {
+        Err(self.unsupported())
+    }
+
+    fn unsupported(self) -> Error {
         Error::Custom("unsupported key".into())
     }
 }

src/ser/mod.rs

@@ -2,12 +2,14 @@
 
 mod key;
 mod pair;
+mod part;
 mod value;
 
 use serde::ser;
 use std::borrow::Cow;
 use std::error;
 use std::fmt;
+use std::marker::PhantomData;
 use std::str;
 use url::form_urlencoded::Serializer as UrlEncodedSerializer;
 use url::form_urlencoded::Target as UrlEncodedTarget;
@@ -27,12 +29,9 @@ use url::form_urlencoded::Target as UrlEncodedTarget;
 ///     Ok("bread=baguette&cheese=comt%C3%A9&meat=ham&fat=butter".to_owned()));
 /// ```
 pub fn to_string<T: ser::Serialize>(input: &T) -> Result<String, Error> {
-    let mut output = String::new();
+    let mut urlencoder = UrlEncodedSerializer::new("".to_owned());
-    {
+    input.serialize(Serializer::new(&mut urlencoder))?;
-        let mut urlencoder = UrlEncodedSerializer::new(&mut output);
+    Ok(urlencoder.finish())
-        input.serialize(&mut Serializer::new(&mut urlencoder))?;
-    }
-    Ok(output)
 }
 
 /// A serializer for the `application/x-www-form-urlencoded` format.
@@ -44,13 +43,13 @@ pub fn to_string<T: ser::Serialize>(input: &T) -> Result<String, Error> {
 ///   unit structs and unit variants.
 ///
 /// * Newtype structs defer to their inner values.
-pub struct Serializer<'output, T: 'output + UrlEncodedTarget> {
+pub struct Serializer<'output, Target: 'output + UrlEncodedTarget> {
-    urlencoder: &'output mut UrlEncodedSerializer<T>,
+    urlencoder: &'output mut UrlEncodedSerializer<Target>,
 }
 
-impl<'output, T: 'output + UrlEncodedTarget> Serializer<'output, T> {
+impl<'output, Target: 'output + UrlEncodedTarget> Serializer<'output, Target> {
     /// Returns a new `Serializer`.
-    pub fn new(urlencoder: &'output mut UrlEncodedSerializer<T>) -> Self {
+    pub fn new(urlencoder: &'output mut UrlEncodedSerializer<Target>) -> Self {
         Serializer { urlencoder: urlencoder }
     }
 }
@@ -59,15 +58,13 @@ impl<'output, T: 'output + UrlEncodedTarget> Serializer<'output, T> {
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum Error {
     Custom(Cow<'static, str>),
-    InvalidValue(Cow<'static, str>),
     Utf8(str::Utf8Error),
 }
 
 impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             Error::Custom(ref msg) => msg.fmt(f),
-            Error::InvalidValue(ref msg) => write!(f, "invalid value: {}", msg),
             Error::Utf8(ref err) => write!(f, "invalid UTF-8: {}", err),
         }
     }
@@ -77,7 +74,6 @@ impl error::Error for Error {
     fn description(&self) -> &str {
         match *self {
             Error::Custom(ref msg) => msg,
-            Error::InvalidValue(ref msg) => msg,
             Error::Utf8(ref err) => error::Error::description(err),
         }
     }
@@ -85,413 +81,432 @@ impl error::Error for Error {
     /// The lower-level cause of this error, in the case of a `Utf8` error.
     fn cause(&self) -> Option<&error::Error> {
         match *self {
-            Error::Custom(_) |
+            Error::Custom(_) => None,
-            Error::InvalidValue(_) => None,
             Error::Utf8(ref err) => Some(err),
         }
     }
 }
 
 impl ser::Error for Error {
-    fn custom<T: Into<String>>(msg: T) -> Self {
+    fn custom<T: fmt::Display>(msg: T) -> Self {
-        Error::Custom(msg.into().into())
+        Error::Custom(format!("{}", msg).into())
-    }
-
-    fn invalid_value(msg: &str) -> Self {
-        Error::InvalidValue(String::from(msg).into())
     }
 }
 
-/// State used when serializing sequences.
+/// Sequence serializer.
-pub struct SeqState {
+pub struct SeqSerializer<'output, Target: 'output + UrlEncodedTarget> {
-    _state: (),
+    urlencoder: &'output mut UrlEncodedSerializer<Target>,
 }
 
-/// State used when serializing tuples.
+/// Tuple serializer.
-pub struct TupleState {
+///
-    _state: (),
+/// Never instantiated, tuples are not supported at top-level.
+pub struct TupleSerializer<'output, T: 'output + UrlEncodedTarget> {
+    _marker: PhantomData<&'output T>,
 }
 
-/// State used when serializing tuple structs.
+/// Tuple struct serializer.
-pub struct TupleStructState {
+///
-    _state: (),
+/// Never instantiated, tuple structs are not supported.
+pub struct TupleStructSerializer<'output, T: 'output + UrlEncodedTarget> {
+    _marker: PhantomData<&'output T>,
 }
 
-/// State used when serializing tuple variants.
+/// Tuple variant serializer.
-pub struct TupleVariantState {
+///
-    _state: (),
+/// Never instantiated, tuple variants are not supported.
+pub struct TupleVariantSerializer<'output, T: 'output + UrlEncodedTarget> {
+    _marker: PhantomData<&'output T>,
 }
 
-/// State used when serializing maps.
+/// Map serializer.
-pub struct MapState {
+pub struct MapSerializer<'output, Target: 'output + UrlEncodedTarget> {
+    urlencoder: &'output mut UrlEncodedSerializer<Target>,
     key: Option<Cow<'static, str>>,
 }
 
-/// State used when serializing structs.
+/// Struct serializer.
-pub struct StructState {
+pub struct StructSerializer<'output, Target: 'output + UrlEncodedTarget> {
-    _state: (),
+    urlencoder: &'output mut UrlEncodedSerializer<Target>,
 }
 
-/// State used when serializing struct variants.
+/// Struct variant serializer.
-pub struct StructVariantState {
+///
-    _state: (),
+/// Never instantiated, struct variants are not supported.
+pub struct StructVariantSerializer<'output, T: 'output + UrlEncodedTarget> {
+    _marker: PhantomData<&'output T>,
 }
 
 impl<'output, Target> ser::Serializer for Serializer<'output, Target>
     where Target: 'output + UrlEncodedTarget,
 {
+    type Ok = &'output mut UrlEncodedSerializer<Target>;
     type Error = Error;
-
+    type SerializeSeq = SeqSerializer<'output, Target>;
-    /// State used when serializing sequences.
+    type SerializeTuple = TupleSerializer<'output, Target>;
-    type SeqState = SeqState;
+    type SerializeTupleStruct = TupleStructSerializer<'output, Target>;
-
+    type SerializeTupleVariant = TupleVariantSerializer<'output, Target>;
-    /// State used when serializing tuples.
+    type SerializeMap = MapSerializer<'output, Target>;
-    type TupleState = TupleState;
+    type SerializeStruct = StructSerializer<'output, Target>;
-
+    type SerializeStructVariant = StructVariantSerializer<'output, Target>;
-    /// State used when serializing tuple structs.
-    type TupleStructState = TupleStructState;
-
-    /// State used when serializing tuple variants.
-    type TupleVariantState = TupleVariantState;
-
-    /// State used when serializing maps.
-    type MapState = MapState;
-
-    /// State used when serializing structs.
-    type StructState = StructState;
-
-    /// State used when serializing struct variants.
-    type StructVariantState = StructVariantState;
 
     /// Returns an error.
-    fn serialize_bool(&mut self, _v: bool) -> Result<(), Error> {
+    fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Error> {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_isize(&mut self, _v: isize) -> Result<(), Error> {
+    fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Error> {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_i8(&mut self, _v: i8) -> Result<(), Error> {
+    fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Error> {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_i16(&mut self, _v: i16) -> Result<(), Error> {
+    fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Error> {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_i32(&mut self, _v: i32) -> Result<(), Error> {
+    fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Error> {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_i64(&mut self, _v: i64) -> Result<(), Error> {
+    fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Error> {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_usize(&mut self, _v: usize) -> Result<(), Error> {
+    fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Error> {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_u8(&mut self, _v: u8) -> Result<(), Error> {
+    fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Error> {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_u16(&mut self, _v: u16) -> Result<(), Error> {
+    fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Error> {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_u32(&mut self, _v: u32) -> Result<(), Error> {
+    fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Error> {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_u64(&mut self, _v: u64) -> Result<(), Error> {
+    fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Error> {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_f32(&mut self, _v: f32) -> Result<(), Error> {
+    fn serialize_char(self, _v: char) -> Result<Self::Ok, Error> {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_f64(&mut self, _v: f64) -> Result<(), Error> {
+    fn serialize_str(self, _value: &str) -> Result<Self::Ok, Error> {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_char(&mut self, _v: char) -> Result<(), Error> {
+    fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, Error> {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_str(&mut self, _value: &str) -> Result<(), Error> {
+    fn serialize_unit(self) -> Result<Self::Ok, Error> {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_bytes(&mut self, _value: &[u8]) -> Result<(), Error> {
+    fn serialize_unit_struct(self,
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_unit(&mut self) -> Result<(), Error> {
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_unit_struct(&mut self,
                              _name: &'static str)
-                             -> Result<(), Error> {
+                             -> Result<Self::Ok, Error> {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_unit_variant(&mut self,
+    fn serialize_unit_variant(self,
                               _name: &'static str,
                               _variant_index: usize,
                               _variant: &'static str)
-                              -> Result<(), Error> {
+                              -> Result<Self::Ok, Error> {
         Err(Error::top_level())
     }
 
     /// Serializes the inner value, ignoring the newtype name.
-    fn serialize_newtype_struct<T>(&mut self,
+    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>
-                                   _name: &'static str,
+        (self,
-                                   value: T)
+         _name: &'static str,
-                                   -> Result<(), Error>
+         value: &T)
-        where T: ser::Serialize,
+         -> Result<Self::Ok, Error> {
-    {
         value.serialize(self)
     }
 
     /// Returns an error.
-    fn serialize_newtype_variant<T>(&mut self,
+    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>
-                                    _name: &'static str,
+        (self,
-                                    _variant_index: usize,
+         _name: &'static str,
-                                    _variant: &'static str,
+         _variant_index: usize,
-                                    _value: T)
+         _variant: &'static str,
-                                    -> Result<(), Error>
+         _value: &T)
-        where T: ser::Serialize,
+         -> Result<Self::Ok, Error> {
-    {
         Err(Error::top_level())
     }
 
-    /// Returns an error.
+    /// Returns `Ok`.
-    fn serialize_none(&mut self) -> Result<(), Error> {
+    fn serialize_none(self) -> Result<Self::Ok, Error> {
-        Ok(())
+        Ok(self.urlencoder)
     }
 
-    /// Returns an error.
+    /// Serializes the given value.
-    fn serialize_some<T>(&mut self, value: T) -> Result<(), Error>
+    fn serialize_some<T: ?Sized + ser::Serialize>
-        where T: ser::Serialize,
+        (self,
-    {
+         value: &T)
+         -> Result<Self::Ok, Error> {
         value.serialize(self)
     }
 
-    /// Begins to serialize a sequence, given length (if any) is ignored.
+    /// Serialize a sequence, given length (if any) is ignored.
-    fn serialize_seq(&mut self,
+    fn serialize_seq(self,
                      _len: Option<usize>)
-                     -> Result<SeqState, Error> {
+                     -> Result<Self::SerializeSeq, Error> {
-        Ok(SeqState { _state: () })
+        Ok(SeqSerializer { urlencoder: self.urlencoder })
     }
 
-    /// Serializes a sequence element.
+    /// Serializes a sequence, given length is ignored.
-    fn serialize_seq_elt<T>(&mut self,
+    fn serialize_seq_fixed_size(self,
-                            _state: &mut SeqState,
+                                _len: usize)
-                            value: T)
+                                -> Result<Self::SerializeSeq, Error> {
-                            -> Result<(), Error>
+        Ok(SeqSerializer { urlencoder: self.urlencoder })
-        where T: ser::Serialize,
-    {
-        value.serialize(&mut pair::PairSerializer::new(self.urlencoder))
-    }
-
-    /// Finishes serializing a sequence.
-    fn serialize_seq_end(&mut self, _state: SeqState) -> Result<(), Error> {
-        Ok(())
-    }
-
-    /// Begins to serialize a sequence, given length is ignored.
-    fn serialize_seq_fixed_size(&mut self,
-                                _length: usize)
-                                -> Result<SeqState, Error> {
-        Ok(SeqState { _state: () })
     }
 
     /// Returns an error.
-    fn serialize_tuple(&mut self, _len: usize) -> Result<TupleState, Error> {
+    fn serialize_tuple(self,
+                       _len: usize)
+                       -> Result<Self::SerializeTuple, Error> {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_tuple_elt<T>(&mut self,
+    fn serialize_tuple_struct(self,
-                              _state: &mut TupleState,
-                              _value: T)
-                              -> Result<(), Error>
-        where T: ser::Serialize,
-    {
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_tuple_end(&mut self, _state: TupleState) -> Result<(), Error> {
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_tuple_struct(&mut self,
                               _name: &'static str,
                               _len: usize)
-                              -> Result<TupleStructState, Error> {
+                              -> Result<Self::SerializeTupleStruct, Error> {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_tuple_struct_elt<T>(&mut self,
+    fn serialize_tuple_variant
-                                     _state: &mut TupleStructState,
+        (self,
-                                     _value: T)
+         _name: &'static str,
-                                     -> Result<(), Error>
+         _variant_index: usize,
-        where T: ser::Serialize,
+         _variant: &'static str,
-    {
+         _len: usize)
+         -> Result<Self::SerializeTupleVariant, Error> {
         Err(Error::top_level())
     }
 
-    /// Returns an error.
+    /// Serializes a map, given length is ignored.
-    fn serialize_tuple_struct_end(&mut self,
+    fn serialize_map(self,
-                                  _state: TupleStructState)
-                                  -> Result<(), Error> {
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_tuple_variant(&mut self,
-                               _name: &'static str,
-                               _variant_index: usize,
-                               _variant: &'static str,
-                               _len: usize)
-                               -> Result<TupleVariantState, Error> {
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_tuple_variant_elt<T>(&mut self,
-                                      _state: &mut TupleVariantState,
-                                      _value: T)
-                                      -> Result<(), Error>
-        where T: ser::Serialize,
-    {
-        Err(Error::top_level())
-    }
-
-    /// Returns an error.
-    fn serialize_tuple_variant_end(&mut self,
-                                   _state: TupleVariantState)
-                                   -> Result<(), Error> {
-        Err(Error::top_level())
-    }
-
-    /// Begins to serialize a map, given length (if any) is ignored.
-    fn serialize_map(&mut self,
                      _len: Option<usize>)
-                     -> Result<MapState, Error> {
+                     -> Result<Self::SerializeMap, Error> {
-        Ok(MapState { key: None })
+        Ok(MapSerializer {
+            urlencoder: self.urlencoder,
+            key: None,
+        })
     }
 
-    /// Serializes a map key.
+    /// Serializes a struct, given length is ignored.
-    fn serialize_map_key<T>(&mut self,
+    fn serialize_struct(self,
-                            state: &mut MapState,
-                            key: T)
-                            -> Result<(), Error>
-        where T: ser::Serialize,
-    {
-        key.serialize(&mut key::MapKeySerializer::new(&mut state.key))
-    }
-
-    /// Serializes a map value.
-    fn serialize_map_value<T>(&mut self,
-                              state: &mut MapState,
-                              value: T)
-                              -> Result<(), Error>
-        where T: ser::Serialize,
-    {
-        let mut value_serializer =
-            value::ValueSerializer::new(&mut state.key, self.urlencoder)?;
-        value.serialize(&mut value_serializer)
-    }
-
-    /// Finishes serializing a map.
-    fn serialize_map_end(&mut self, _state: MapState) -> Result<(), Error> {
-        Ok(())
-    }
-
-    /// Begins to serialize a struct, given length is ignored.
-    fn serialize_struct(&mut self,
                         _name: &'static str,
                         _len: usize)
-                        -> Result<StructState, Error> {
+                        -> Result<Self::SerializeStruct, Error> {
-        Ok(StructState { _state: () })
+        Ok(StructSerializer { urlencoder: self.urlencoder })
     }
 
-    /// Serializes a struct element.
+    /// Returns an error.
-    fn serialize_struct_elt<T>(&mut self,
+    fn serialize_struct_variant
-                               _state: &mut StructState,
+        (self,
-                               key: &'static str,
+         _name: &'static str,
-                               value: T)
+         _variant_index: usize,
-                               -> Result<(), Error>
+         _variant: &'static str,
-        where T: ser::Serialize,
+         _len: usize)
-    {
+         -> Result<Self::SerializeStructVariant, Error> {
-        let mut key = Some(key.into());
+        Err(Error::top_level())
-        let mut value_serializer =
+    }
-            value::ValueSerializer::new(&mut key, self.urlencoder).unwrap();
+}
-        value.serialize(&mut value_serializer)
+
+impl<'output, Target> ser::SerializeSeq for SeqSerializer<'output, Target>
+    where Target: 'output + UrlEncodedTarget,
+{
+    type Ok = &'output mut UrlEncodedSerializer<Target>;
+    type Error = Error;
+
+    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self,
+                                                     value: &T)
+                                                     -> Result<(), Error> {
+        value.serialize(pair::PairSerializer::new(self.urlencoder))
     }
 
-    /// Finishes serializing a struct.
+    fn end(self) -> Result<Self::Ok, Error> {
-    fn serialize_struct_end(&mut self,
+        Ok(self.urlencoder)
-                            _state: StructState)
+    }
-                            -> Result<(), Error> {
+}
+
+impl<'output, Target> ser::SerializeTuple for TupleSerializer<'output, Target>
+    where Target: 'output + UrlEncodedTarget,
+{
+    type Ok = &'output mut UrlEncodedSerializer<Target>;
+    type Error = Error;
+
+    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self,
+                                                     _value: &T)
+                                                     -> Result<(), Error> {
+        unreachable!()
+    }
+
+    fn end(self) -> Result<Self::Ok, Error> {
+        unreachable!()
+    }
+}
+
+impl<'output, Target> ser::SerializeTupleStruct
+    for TupleStructSerializer<'output, Target>
+    where Target: 'output + UrlEncodedTarget,
+{
+    type Ok = &'output mut UrlEncodedSerializer<Target>;
+    type Error = Error;
+
+    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
+                                                   _value: &T)
+                                                   -> Result<(), Error> {
+        unreachable!()
+    }
+
+    fn end(self) -> Result<Self::Ok, Error> {
+        unreachable!()
+    }
+}
+
+impl<'output, Target> ser::SerializeTupleVariant
+    for TupleVariantSerializer<'output, Target>
+    where Target: 'output + UrlEncodedTarget,
+{
+    type Ok = &'output mut UrlEncodedSerializer<Target>;
+    type Error = Error;
+
+    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
+                                                   _value: &T)
+                                                   -> Result<(), Error> {
+        unreachable!()
+    }
+
+    fn end(self) -> Result<Self::Ok, Error> {
+        unreachable!()
+    }
+}
+
+impl<'output, Target> ser::SerializeMap for MapSerializer<'output, Target>
+    where Target: 'output + UrlEncodedTarget,
+{
+    type Ok = &'output mut UrlEncodedSerializer<Target>;
+    type Error = Error;
+
+    fn serialize_entry<K: ?Sized + ser::Serialize, V: ?Sized + ser::Serialize>
+        (&mut self,
+         key: &K,
+         value: &V)
+         -> Result<(), Error> {
+        let key_sink = key::KeySink::new(|key| {
+            let value_sink = value::ValueSink::new(self.urlencoder, &key);
+            value.serialize(part::PartSerializer::new(value_sink))?;
+            self.key = None;
+            Ok(())
+        });
+        let entry_serializer = part::PartSerializer::new(key_sink);
+        key.serialize(entry_serializer)
+    }
+
+    fn serialize_key<T: ?Sized + ser::Serialize>(&mut self,
+                                                 key: &T)
+                                                 -> Result<(), Error> {
+        let key_sink = key::KeySink::new(|key| Ok(key.into()));
+        let key_serializer = part::PartSerializer::new(key_sink);
+        self.key = Some(key.serialize(key_serializer)?);
         Ok(())
     }
 
-    /// Returns an error.
+    fn serialize_value<T: ?Sized + ser::Serialize>(&mut self,
-    fn serialize_struct_variant(&mut self,
+                                                   value: &T)
-                                _name: &'static str,
+                                                   -> Result<(), Error> {
-                                _variant_index: usize,
+        {
-                                _variant: &'static str,
+            let key = self.key.as_ref().ok_or_else(|| Error::no_key())?;
-                                _len: usize)
+            let value_sink = value::ValueSink::new(self.urlencoder, &key);
-                                -> Result<StructVariantState, Error> {
+            value.serialize(part::PartSerializer::new(value_sink))?;
-        Err(Error::top_level())
+        }
+        self.key = None;
+        Ok(())
     }
 
-    /// Returns an error.
+    fn end(self) -> Result<Self::Ok, Error> {
-    fn serialize_struct_variant_elt<T>(&mut self,
+        Ok(self.urlencoder)
-                                       _state: &mut StructVariantState,
+    }
-                                       _key: &'static str,
+}
-                                       _value: T)
+
-                                       -> Result<(), Error> {
+impl<'output, Target> ser::SerializeStruct for StructSerializer<'output, Target>
-        Err(Error::top_level())
+    where Target: 'output + UrlEncodedTarget,
+{
+    type Ok = &'output mut UrlEncodedSerializer<Target>;
+    type Error = Error;
+
+    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
+                                                   key: &'static str,
+                                                   value: &T)
+                                                   -> Result<(), Error> {
+        let value_sink = value::ValueSink::new(self.urlencoder, key);
+        value.serialize(part::PartSerializer::new(value_sink))
     }
 
-    /// Returns an error.
+    fn end(self) -> Result<Self::Ok, Error> {
-    fn serialize_struct_variant_end(&mut self,
+        Ok(self.urlencoder)
-                                    _state: StructVariantState)
+    }
-                                    -> Result<(), Error> {
+}
-        Err(Error::top_level())
+
+impl<'output, Target> ser::SerializeStructVariant
+    for StructVariantSerializer<'output, Target>
+    where Target: 'output + UrlEncodedTarget,
+{
+    type Ok = &'output mut UrlEncodedSerializer<Target>;
+    type Error = Error;
+
+    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
+                                                   _key: &'static str,
+                                                   _value: &T)
+                                                   -> Result<(), Error> {
+        unreachable!()
+    }
+
+    fn end(self) -> Result<Self::Ok, Error> {
+        unreachable!()
     }
 }
 
 impl Error {
     fn top_level() -> Self {
-        Error::Custom("top-level serializer supports only maps and structs"
+        let msg = "top-level serializer supports only maps and structs";
-            .into())
+        Error::Custom(msg.into())
+    }
+
+    fn no_key() -> Self {
+        let msg = "tried to serialize a value before serializing key";
+        Error::Custom(msg.into())
     }
 }

src/ser/pair.rs

@@ -1,111 +1,107 @@
-use ser::{Error, key, value};
+use ser::Error;
-use serde::{Serialize, Serializer};
+use ser::key::KeySink;
+use ser::part::PartSerializer;
+use ser::value::ValueSink;
+use serde::ser;
 use std::borrow::Cow;
-use url::form_urlencoded;
+use std::mem;
+use url::form_urlencoded::Serializer as UrlEncodedSerializer;
+use url::form_urlencoded::Target as UrlEncodedTarget;
 
-pub struct PairSerializer<'target, Target>(
+pub struct PairSerializer<'target, Target: 'target + UrlEncodedTarget> {
-        &'target mut form_urlencoded::Serializer<Target>)
+    urlencoder: &'target mut UrlEncodedSerializer<Target>,
-    where Target: 'target + form_urlencoded::Target;
+    state: PairState,
+}
 
 impl<'target, Target> PairSerializer<'target, Target>
-    where Target: 'target + form_urlencoded::Target,
+    where Target: 'target + UrlEncodedTarget,
 {
-    pub fn new(serializer: &'target mut form_urlencoded::Serializer<Target>)
+    pub fn new(urlencoder: &'target mut UrlEncodedSerializer<Target>) -> Self {
-               -> Self {
+        PairSerializer {
-        PairSerializer(serializer)
+            urlencoder: urlencoder,
+            state: PairState::WaitingForKey,
+        }
     }
 }
 
-pub struct TupleState(Option<Option<Cow<'static, str>>>);
+impl<'target, Target> ser::Serializer for PairSerializer<'target, Target>
-pub struct TupleStructState(TupleState);
+    where Target: 'target + UrlEncodedTarget,
-
-impl<'target, Target> Serializer for PairSerializer<'target, Target>
-    where Target: 'target + form_urlencoded::Target,
 {
+    type Ok = ();
     type Error = Error;
-    type SeqState = ();
+    type SerializeSeq = Self;
-    type TupleState = TupleState;
+    type SerializeTuple = Self;
-    type TupleStructState = TupleStructState;
+    type SerializeTupleStruct = Self;
-    type TupleVariantState = ();
+    type SerializeTupleVariant = Self;
-    type MapState = ();
+    type SerializeMap = Self;
-    type StructState = ();
+    type SerializeStruct = Self;
-    type StructVariantState = ();
+    type SerializeStructVariant = Self;
 
-    fn serialize_bool(&mut self, _v: bool) -> Result<(), Error> {
+    fn serialize_bool(self, _v: bool) -> Result<(), Error> {
-        Err(Error::Custom("booleans are not supported values".into()))
-    }
-
-    fn serialize_isize(&mut self, _v: isize) -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_i8(&mut self, _v: i8) -> Result<(), Error> {
+    fn serialize_i8(self, _v: i8) -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_i16(&mut self, _v: i16) -> Result<(), Error> {
+    fn serialize_i16(self, _v: i16) -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_i32(&mut self, _v: i32) -> Result<(), Error> {
+    fn serialize_i32(self, _v: i32) -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_i64(&mut self, _v: i64) -> Result<(), Error> {
+    fn serialize_i64(self, _v: i64) -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_usize(&mut self, _v: usize) -> Result<(), Error> {
+    fn serialize_u8(self, _v: u8) -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_u8(&mut self, _v: u8) -> Result<(), Error> {
+    fn serialize_u16(self, _v: u16) -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_u16(&mut self, _v: u16) -> Result<(), Error> {
+    fn serialize_u32(self, _v: u32) -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_u32(&mut self, _v: u32) -> Result<(), Error> {
+    fn serialize_u64(self, _v: u64) -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_u64(&mut self, _v: u64) -> Result<(), Error> {
+    fn serialize_f32(self, _v: f32) -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_f32(&mut self, _v: f32) -> Result<(), Error> {
+    fn serialize_f64(self, _v: f64) -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_f64(&mut self, _v: f64) -> Result<(), Error> {
+    fn serialize_char(self, _v: char) -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_char(&mut self, _v: char) -> Result<(), Error> {
+    fn serialize_str(self, _value: &str) -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_str(&mut self, _value: &str) -> Result<(), Error> {
+    fn serialize_bytes(self, _value: &[u8]) -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_bytes(&mut self, _value: &[u8]) -> Result<(), Error> {
+    fn serialize_unit(self) -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_unit(&mut self) -> Result<(), Error> {
+    fn serialize_unit_struct(self, _name: &'static str) -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_unit_struct(&mut self,
+    fn serialize_unit_variant(self,
-                             _name: &'static str)
-                             -> Result<(), Error> {
-        Err(Error::unsupported_pair())
-    }
-
-    fn serialize_unit_variant(&mut self,
                               _name: &'static str,
                               _variant_index: usize,
                               _variant: &'static str)
@@ -113,213 +109,259 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target>
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_newtype_struct<T>(&mut self,
+    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>
-                                   _name: &'static str,
+        (self,
-                                   value: T)
+         _name: &'static str,
-                                   -> Result<(), Error>
+         value: &T)
-        where T: Serialize,
+         -> Result<(), Error> {
-    {
         value.serialize(self)
     }
 
-    fn serialize_newtype_variant<T>(&mut self,
+    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>
-                                    _name: &'static str,
+        (self,
-                                    _variant_index: usize,
+         _name: &'static str,
-                                    _variant: &'static str,
+         _variant_index: usize,
-                                    _value: T)
+         _variant: &'static str,
-                                    -> Result<(), Error>
+         _value: &T)
-        where T: Serialize,
+         -> Result<(), Error> {
-    {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_none(&mut self) -> Result<(), Error> {
+    fn serialize_none(self) -> Result<(), Error> {
         Ok(())
     }
 
-    fn serialize_some<T>(&mut self, value: T) -> Result<(), Error>
+    fn serialize_some<T: ?Sized + ser::Serialize>(self,
-        where T: Serialize,
+                                                  value: &T)
-    {
+                                                  -> Result<(), Error> {
         value.serialize(self)
     }
 
-    fn serialize_seq(&mut self, _len: Option<usize>) -> Result<(), Error> {
+    fn serialize_seq(self, _len: Option<usize>) -> Result<Self, Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_seq_elt<T>(&mut self,
+    fn serialize_seq_fixed_size(self, _len: usize) -> Result<Self, Error> {
-                            _state: &mut (),
-                            _value: T)
-                            -> Result<(), Error>
-        where T: Serialize,
-    {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_seq_end(&mut self, _state: ()) -> Result<(), Error> {
+    fn serialize_tuple(self, len: usize) -> Result<Self, Error> {
-        Err(Error::unsupported_pair())
-    }
-
-    fn serialize_seq_fixed_size(&mut self, _size: usize) -> Result<(), Error> {
-        Err(Error::unsupported_pair())
-    }
-
-    fn serialize_tuple(&mut self, len: usize) -> Result<TupleState, Error> {
         if len == 2 {
-            Ok(TupleState(None))
+            Ok(self)
         } else {
             Err(Error::unsupported_pair())
         }
     }
 
-    fn serialize_tuple_elt<T>(&mut self,
+    fn serialize_tuple_struct(self,
-                              state: &mut TupleState,
-                              value: T)
-                              -> Result<(), Error>
-        where T: Serialize,
-    {
-        match state.0.take() {
-            None => {
-                let mut key = None;
-                {
-                    let mut key_serializer =
-                        key::MapKeySerializer::new(&mut key);
-                    value.serialize(&mut key_serializer)?;
-                }
-                state.0 = Some(key);
-                Ok(())
-            },
-            Some(ref mut key) => {
-                {
-                    let mut value_serializer =
-                        value::ValueSerializer::new(key, &mut self.0).unwrap();
-                    value.serialize(&mut value_serializer)?;
-                }
-                state.0 = Some(None);
-                Ok(())
-            },
-        }
-    }
-
-    fn serialize_tuple_end(&mut self, _state: TupleState) -> Result<(), Error> {
-        Ok(())
-    }
-
-    fn serialize_tuple_struct(&mut self,
                               _name: &'static str,
-                              len: usize)
+                              _len: usize)
-                              -> Result<TupleStructState, Error> {
+                              -> Result<Self, Error> {
-        self.serialize_tuple(len).map(TupleStructState)
+        Err(Error::unsupported_pair())
     }
 
-    fn serialize_tuple_struct_elt<T>(&mut self,
+    fn serialize_tuple_variant(self,
-                                     state: &mut TupleStructState,
-                                     value: T)
-                                     -> Result<(), Error>
-        where T: Serialize,
-    {
-        self.serialize_tuple_elt(&mut state.0, value)
-    }
-
-    fn serialize_tuple_struct_end(&mut self,
-                                  _state: TupleStructState)
-                                  -> Result<(), Error> {
-        Ok(())
-    }
-
-    fn serialize_tuple_variant(&mut self,
                                _name: &'static str,
                                _variant_index: usize,
                                _variant: &'static str,
                                _len: usize)
-                               -> Result<(), Error> {
+                               -> Result<Self, Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_tuple_variant_elt<T>(&mut self,
+    fn serialize_map(self, _len: Option<usize>) -> Result<Self, Error> {
-                                      _state: &mut (),
-                                      _value: T)
-                                      -> Result<(), Error>
-        where T: Serialize,
-    {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_tuple_variant_end(&mut self, _state: ()) -> Result<(), Error> {
+    fn serialize_struct(self,
-        Err(Error::unsupported_pair())
-    }
-
-    fn serialize_map(&mut self, _len: Option<usize>) -> Result<(), Error> {
-        Err(Error::unsupported_pair())
-    }
-
-    fn serialize_map_key<T>(&mut self,
-                            _state: &mut (),
-                            _key: T)
-                            -> Result<(), Error>
-        where T: Serialize,
-    {
-        Err(Error::unsupported_pair())
-    }
-
-    fn serialize_map_value<T>(&mut self,
-                              _state: &mut (),
-                              _value: T)
-                              -> Result<(), Error>
-        where T: Serialize,
-    {
-        Err(Error::unsupported_pair())
-    }
-
-    fn serialize_map_end(&mut self, _state: ()) -> Result<(), Error> {
-        Err(Error::unsupported_pair())
-    }
-
-    fn serialize_struct(&mut self,
                         _name: &'static str,
                         _len: usize)
-                        -> Result<(), Error> {
+                        -> Result<Self, Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_struct_elt<T>(&mut self,
+    fn serialize_struct_variant(self,
-                               _state: &mut (),
-                               _key: &'static str,
-                               _value: T)
-                               -> Result<(), Error>
-        where T: Serialize,
-    {
-        Err(Error::unsupported_pair())
-    }
-
-    fn serialize_struct_end(&mut self, _state: ()) -> Result<(), Error> {
-        Err(Error::unsupported_pair())
-    }
-
-    fn serialize_struct_variant(&mut self,
                                 _name: &'static str,
                                 _variant_index: usize,
                                 _variant: &'static str,
                                 _len: usize)
-                                -> Result<(), Error> {
+                                -> Result<Self, Error> {
-        Err(Error::unsupported_pair())
-    }
-    fn serialize_struct_variant_elt<T>(&mut self,
-                                       _state: &mut (),
-                                       _key: &'static str,
-                                       _value: T)
-                                       -> Result<(), Error> {
-        Err(Error::unsupported_pair())
-    }
-
-    fn serialize_struct_variant_end(&mut self,
-                                    _state: ())
-                                    -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 }
 
+impl<'target, Target> ser::SerializeSeq for PairSerializer<'target, Target>
+    where Target: 'target + UrlEncodedTarget,
+{
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self,
+                                                     _value: &T)
+                                                     -> Result<(), Error> {
+        unreachable!()
+    }
+
+    fn end(self) -> Result<(), Error> {
+        unreachable!()
+    }
+}
+
+impl<'target, Target> ser::SerializeTuple for PairSerializer<'target, Target>
+    where Target: 'target + UrlEncodedTarget,
+{
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self,
+                                                     value: &T)
+                                                     -> Result<(), Error> {
+        match mem::replace(&mut self.state, PairState::Done) {
+            PairState::WaitingForKey => {
+                let key_sink = KeySink::new(|key| Ok(key.into()));
+                let key_serializer = PartSerializer::new(key_sink);
+                self.state = PairState::WaitingForValue {
+                    key: value.serialize(key_serializer)?,
+                };
+                Ok(())
+            },
+            PairState::WaitingForValue { key } => {
+                let result = {
+                    let value_sink = ValueSink::new(self.urlencoder, &key);
+                    let value_serializer = PartSerializer::new(value_sink);
+                    value.serialize(value_serializer)
+                };
+                if result.is_ok() {
+                    self.state = PairState::Done;
+                } else {
+                    self.state = PairState::WaitingForValue { key: key };
+                }
+                result
+            },
+            PairState::Done => Err(Error::done()),
+        }
+    }
+
+    fn end(self) -> Result<(), Error> {
+        if let PairState::Done = self.state {
+            Ok(())
+        } else {
+            Err(Error::not_done())
+        }
+    }
+}
+
+impl<'target, Target> ser::SerializeTupleStruct
+    for PairSerializer<'target, Target>
+    where Target: 'target + UrlEncodedTarget,
+{
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
+                                                   _value: &T)
+                                                   -> Result<(), Error> {
+        unreachable!()
+    }
+
+    fn end(self) -> Result<(), Error> {
+        unreachable!()
+    }
+}
+
+impl<'target, Target> ser::SerializeTupleVariant
+    for PairSerializer<'target, Target>
+    where Target: 'target + UrlEncodedTarget,
+{
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
+                                                   _value: &T)
+                                                   -> Result<(), Error> {
+        unreachable!()
+    }
+
+    fn end(self) -> Result<(), Error> {
+        unreachable!()
+    }
+}
+
+impl<'target, Target> ser::SerializeMap for PairSerializer<'target, Target>
+    where Target: 'target + UrlEncodedTarget,
+{
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_key<T: ?Sized + ser::Serialize>(&mut self,
+                                                 _key: &T)
+                                                 -> Result<(), Error> {
+        unreachable!()
+    }
+
+    fn serialize_value<T: ?Sized + ser::Serialize>(&mut self,
+                                                   _value: &T)
+                                                   -> Result<(), Error> {
+        unreachable!()
+    }
+
+    fn end(self) -> Result<(), Error> {
+        unreachable!()
+    }
+}
+
+impl<'target, Target> ser::SerializeStruct for PairSerializer<'target, Target>
+    where Target: 'target + UrlEncodedTarget,
+{
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
+                                                   _key: &'static str,
+                                                   _value: &T)
+                                                   -> Result<(), Error> {
+        unreachable!()
+    }
+
+    fn end(self) -> Result<(), Error> {
+        unreachable!()
+    }
+}
+
+impl<'target, Target> ser::SerializeStructVariant
+    for PairSerializer<'target, Target>
+    where Target: 'target + UrlEncodedTarget,
+{
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
+                                                   _key: &'static str,
+                                                   _value: &T)
+                                                   -> Result<(), Error> {
+        unreachable!()
+    }
+
+    fn end(self) -> Result<(), Error> {
+        unreachable!()
+    }
+}
+
+enum PairState {
+    WaitingForKey,
+    WaitingForValue { key: Cow<'static, str> },
+    Done,
+}
+
 impl Error {
+    fn done() -> Self {
+        Error::Custom("this pair has already been serialized".into())
+    }
+
+    fn not_done() -> Self {
+        Error::Custom("this pair has not yet been serialized".into())
+    }
+
     fn unsupported_pair() -> Self {
         Error::Custom("unsupported pair".into())
     }

src/ser/part.rs

@@ -0,0 +1,311 @@
+use ser::Error;
+use serde::ser;
+use std::str;
+
+pub struct PartSerializer<S> {
+    sink: S,
+}
+
+impl<S: Sink> PartSerializer<S> {
+    pub fn new(sink: S) -> Self {
+        PartSerializer { sink: sink }
+    }
+}
+
+pub trait Sink: Sized {
+    type Ok;
+
+    fn serialize_bool(self, value: bool) -> Result<Self::Ok, Error>;
+
+    fn serialize_static_str(self,
+                            value: &'static str)
+                            -> Result<Self::Ok, Error>;
+
+    fn serialize_str(self, value: &str) -> Result<Self::Ok, Error>;
+    fn serialize_string(self, value: String) -> Result<Self::Ok, Error>;
+    fn serialize_none(self) -> Result<Self::Ok, Error>;
+
+    fn serialize_some<T: ?Sized + ser::Serialize>
+        (self,
+         value: &T)
+         -> Result<Self::Ok, Error>;
+
+    fn unsupported(self) -> Error;
+}
+
+impl<S: Sink> ser::Serializer for PartSerializer<S> {
+    type Ok = S::Ok;
+    type Error = Error;
+    type SerializeSeq = Self;
+    type SerializeTuple = Self;
+    type SerializeTupleStruct = Self;
+    type SerializeTupleVariant = Self;
+    type SerializeMap = Self;
+    type SerializeStruct = Self;
+    type SerializeStructVariant = Self;
+
+    fn serialize_bool(self, v: bool) -> Result<S::Ok, Error> {
+        self.sink.serialize_bool(v)
+    }
+
+    fn serialize_i8(self, v: i8) -> Result<S::Ok, Error> {
+        self.sink.serialize_string(v.to_string())
+    }
+
+    fn serialize_i16(self, v: i16) -> Result<S::Ok, Error> {
+        self.sink.serialize_string(v.to_string())
+    }
+
+    fn serialize_i32(self, v: i32) -> Result<S::Ok, Error> {
+        self.sink.serialize_string(v.to_string())
+    }
+
+    fn serialize_i64(self, v: i64) -> Result<S::Ok, Error> {
+        self.sink.serialize_string(v.to_string())
+    }
+
+    fn serialize_u8(self, v: u8) -> Result<S::Ok, Error> {
+        self.sink.serialize_string(v.to_string())
+    }
+
+    fn serialize_u16(self, v: u16) -> Result<S::Ok, Error> {
+        self.sink.serialize_string(v.to_string())
+    }
+
+    fn serialize_u32(self, v: u32) -> Result<S::Ok, Error> {
+        self.sink.serialize_string(v.to_string())
+    }
+
+    fn serialize_u64(self, v: u64) -> Result<S::Ok, Error> {
+        self.sink.serialize_string(v.to_string())
+    }
+
+    fn serialize_f32(self, v: f32) -> Result<S::Ok, Error> {
+        self.sink.serialize_string(v.to_string())
+    }
+
+    fn serialize_f64(self, v: f64) -> Result<S::Ok, Error> {
+        self.sink.serialize_string(v.to_string())
+    }
+
+    fn serialize_char(self, v: char) -> Result<S::Ok, Error> {
+        self.sink.serialize_string(v.to_string())
+    }
+
+    fn serialize_str(self, value: &str) -> Result<S::Ok, Error> {
+        self.sink.serialize_str(value)
+    }
+
+    fn serialize_bytes(self, value: &[u8]) -> Result<S::Ok, Error> {
+        match str::from_utf8(value) {
+            Ok(value) => self.sink.serialize_str(value),
+            Err(err) => Err(Error::Utf8(err)),
+        }
+    }
+
+    fn serialize_unit(self) -> Result<S::Ok, Error> {
+        Err(self.sink.unsupported())
+    }
+
+    fn serialize_unit_struct(self, name: &'static str) -> Result<S::Ok, Error> {
+        self.sink.serialize_static_str(name.into())
+    }
+
+    fn serialize_unit_variant(self,
+                              _name: &'static str,
+                              _variant_index: usize,
+                              variant: &'static str)
+                              -> Result<S::Ok, Error> {
+        self.sink.serialize_static_str(variant.into())
+    }
+
+    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>
+        (self,
+         _name: &'static str,
+         value: &T)
+         -> Result<S::Ok, Error> {
+        value.serialize(self)
+    }
+
+    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>
+        (self,
+         _name: &'static str,
+         _variant_index: usize,
+         _variant: &'static str,
+         _value: &T)
+         -> Result<S::Ok, Error> {
+        Err(self.sink.unsupported())
+    }
+
+    fn serialize_none(self) -> Result<S::Ok, Error> {
+        self.sink.serialize_none()
+    }
+
+    fn serialize_some<T: ?Sized + ser::Serialize>(self,
+                                                  value: &T)
+                                                  -> Result<S::Ok, Error> {
+        self.sink.serialize_some(value)
+    }
+
+    fn serialize_seq(self, _len: Option<usize>) -> Result<Self, Error> {
+        Err(self.sink.unsupported())
+    }
+
+
+    fn serialize_seq_fixed_size(self, _len: usize) -> Result<Self, Error> {
+        Err(self.sink.unsupported())
+    }
+
+    fn serialize_tuple(self, _len: usize) -> Result<Self, Error> {
+        Err(self.sink.unsupported())
+    }
+
+    fn serialize_tuple_struct(self,
+                              _name: &'static str,
+                              _len: usize)
+                              -> Result<Self, Error> {
+        Err(self.sink.unsupported())
+    }
+
+    fn serialize_tuple_variant(self,
+                               _name: &'static str,
+                               _variant_index: usize,
+                               _variant: &'static str,
+                               _len: usize)
+                               -> Result<Self, Error> {
+        Err(self.sink.unsupported())
+    }
+
+    fn serialize_map(self, _len: Option<usize>) -> Result<Self, Error> {
+        Err(self.sink.unsupported())
+    }
+
+    fn serialize_struct(self,
+                        _name: &'static str,
+                        _len: usize)
+                        -> Result<Self, Error> {
+        Err(self.sink.unsupported())
+    }
+
+    fn serialize_struct_variant(self,
+                                _name: &'static str,
+                                _variant_index: usize,
+                                _variant: &'static str,
+                                _len: usize)
+                                -> Result<Self, Error> {
+        Err(self.sink.unsupported())
+    }
+}
+
+impl<S: Sink> ser::SerializeSeq for PartSerializer<S> {
+    type Ok = S::Ok;
+    type Error = Error;
+
+    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self,
+                                                     _value: &T)
+                                                     -> Result<(), Error> {
+        unreachable!()
+    }
+
+    fn end(self) -> Result<S::Ok, Error> {
+        unreachable!()
+    }
+}
+
+impl<S: Sink> ser::SerializeTuple for PartSerializer<S> {
+    type Ok = S::Ok;
+    type Error = Error;
+
+    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self,
+                                                     _value: &T)
+                                                     -> Result<(), Error> {
+        unreachable!()
+    }
+
+    fn end(self) -> Result<S::Ok, Error> {
+        unreachable!()
+    }
+}
+
+impl<S: Sink> ser::SerializeTupleStruct for PartSerializer<S> {
+    type Ok = S::Ok;
+    type Error = Error;
+
+    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
+                                                   _value: &T)
+                                                   -> Result<(), Error> {
+        unreachable!()
+    }
+
+    fn end(self) -> Result<S::Ok, Error> {
+        unreachable!()
+    }
+}
+
+impl<S: Sink> ser::SerializeTupleVariant for PartSerializer<S> {
+    type Ok = S::Ok;
+    type Error = Error;
+
+    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
+                                                   _value: &T)
+                                                   -> Result<(), Error> {
+        unreachable!()
+    }
+
+    fn end(self) -> Result<S::Ok, Error> {
+        unreachable!()
+    }
+}
+
+impl<S: Sink> ser::SerializeMap for PartSerializer<S> {
+    type Ok = S::Ok;
+    type Error = Error;
+
+    fn serialize_key<T: ?Sized + ser::Serialize>(&mut self,
+                                                 _key: &T)
+                                                 -> Result<(), Error> {
+        unreachable!()
+    }
+
+    fn serialize_value<T: ?Sized + ser::Serialize>(&mut self,
+                                                   _value: &T)
+                                                   -> Result<(), Error> {
+        unreachable!()
+    }
+
+    fn end(self) -> Result<S::Ok, Error> {
+        unreachable!()
+    }
+}
+
+impl<S: Sink> ser::SerializeStruct for PartSerializer<S> {
+    type Ok = S::Ok;
+    type Error = Error;
+
+    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
+                                                   _key: &'static str,
+                                                   _value: &T)
+                                                   -> Result<(), Error> {
+        unreachable!()
+    }
+
+    fn end(self) -> Result<S::Ok, Error> {
+        unreachable!()
+    }
+}
+
+impl<S: Sink> ser::SerializeStructVariant for PartSerializer<S> {
+    type Ok = S::Ok;
+    type Error = Error;
+
+    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
+                                                   _key: &'static str,
+                                                   _value: &T)
+                                                   -> Result<(), Error> {
+        unreachable!()
+    }
+
+    fn end(self) -> Result<S::Ok, Error> {
+        unreachable!()
+    }
+}

src/ser/value.rs

@@ -1,331 +1,63 @@
 use ser::Error;
-use serde::{Serialize, Serializer};
+use ser::part::{PartSerializer, Sink};
-use std::borrow::Cow;
+use serde::ser::Serialize;
 use std::str;
-use url::form_urlencoded;
+use url::form_urlencoded::Serializer as UrlEncodedSerializer;
+use url::form_urlencoded::Target as UrlEncodedTarget;
 
-pub struct ValueSerializer<'key, 'target, Target>
+pub struct ValueSink<'key, 'target, Target>
-    where Target: 'target + form_urlencoded::Target,
+    where Target: 'target + UrlEncodedTarget,
 {
-    key: &'key mut Option<Cow<'static, str>>,
+    urlencoder: &'target mut UrlEncodedSerializer<Target>,
-    serializer: &'target mut form_urlencoded::Serializer<Target>,
+    key: &'key str,
 }
 
-impl<'key, 'target, Target> ValueSerializer<'key, 'target, Target>
+impl<'key, 'target, Target> ValueSink<'key, 'target, Target>
-    where Target: 'target + form_urlencoded::Target,
+    where Target: 'target + UrlEncodedTarget,
 {
-    pub fn new(key: &'key mut Option<Cow<'static, str>>,
+    pub fn new(urlencoder: &'target mut UrlEncodedSerializer<Target>,
-               serializer: &'target mut form_urlencoded::Serializer<Target>)
+               key: &'key str)
-               -> Result<Self, Error> {
+               -> Self {
-        if key.is_some() {
+        ValueSink {
-            Ok(ValueSerializer {
+            urlencoder: urlencoder,
-                key: key,
+            key: key,
-                serializer: serializer,
-            })
-        } else {
-            Err(Error::no_key())
-        }
-    }
-
-    fn append_pair(&mut self, value: &str) -> Result<(), Error> {
-        if let Some(key) = self.key.take() {
-            self.serializer.append_pair(&key, value);
-            Ok(())
-        } else {
-            Err(Error::no_key())
         }
     }
 }
 
-impl<'key, 'target, Target> Serializer
+impl<'key, 'target, Target> Sink for ValueSink<'key, 'target, Target>
-    for ValueSerializer<'key, 'target, Target>
+    where Target: 'target + UrlEncodedTarget,
-    where Target: 'target + form_urlencoded::Target,
 {
-    type Error = Error;
+    type Ok = ();
-    type SeqState = ();
-    type TupleState = ();
-    type TupleStructState = ();
-    type TupleVariantState = ();
-    type MapState = ();
-    type StructState = ();
-    type StructVariantState = ();
 
-    fn serialize_bool(&mut self, v: bool) -> Result<(), Error> {
+    fn serialize_bool(self, value: bool) -> Result<Self::Ok, Error> {
-        self.append_pair(if v { "true" } else { "false" })
+        self.serialize_string(value.to_string())
     }
 
-    fn serialize_isize(&mut self, v: isize) -> Result<(), Error> {
+    fn serialize_str(self, value: &str) -> Result<(), Error> {
-        self.append_pair(&v.to_string())
+        self.urlencoder.append_pair(self.key, value);
+        Ok(())
     }
 
-    fn serialize_i8(&mut self, v: i8) -> Result<(), Error> {
+    fn serialize_static_str(self, value: &'static str) -> Result<(), Error> {
-        self.append_pair(&v.to_string())
+        self.serialize_str(value)
     }
 
-    fn serialize_i16(&mut self, v: i16) -> Result<(), Error> {
+    fn serialize_string(self, value: String) -> Result<(), Error> {
-        self.append_pair(&v.to_string())
+        self.serialize_str(&value)
     }
 
-    fn serialize_i32(&mut self, v: i32) -> Result<(), Error> {
+    fn serialize_none(self) -> Result<Self::Ok, Error> {
-        self.append_pair(&v.to_string())
+        Ok(())
     }
 
-    fn serialize_i64(&mut self, v: i64) -> Result<(), Error> {
+    fn serialize_some<T: ?Sized + Serialize>(self,
-        self.append_pair(&v.to_string())
+                                             value: &T)
+                                             -> Result<Self::Ok, Error> {
+        value.serialize(PartSerializer::new(self))
     }
 
-    fn serialize_usize(&mut self, v: usize) -> Result<(), Error> {
+    fn unsupported(self) -> Error {
-        self.append_pair(&v.to_string())
-    }
-
-    fn serialize_u8(&mut self, v: u8) -> Result<(), Error> {
-        self.append_pair(&v.to_string())
-    }
-
-    fn serialize_u16(&mut self, v: u16) -> Result<(), Error> {
-        self.append_pair(&v.to_string())
-    }
-
-    fn serialize_u32(&mut self, v: u32) -> Result<(), Error> {
-        self.append_pair(&v.to_string())
-    }
-
-    fn serialize_u64(&mut self, v: u64) -> Result<(), Error> {
-        self.append_pair(&v.to_string())
-    }
-
-    fn serialize_f32(&mut self, v: f32) -> Result<(), Error> {
-        self.append_pair(&v.to_string())
-    }
-
-    fn serialize_f64(&mut self, v: f64) -> Result<(), Error> {
-        self.append_pair(&v.to_string())
-    }
-
-    fn serialize_char(&mut self, v: char) -> Result<(), Error> {
-        self.append_pair(&v.to_string())
-    }
-
-    fn serialize_str(&mut self, value: &str) -> Result<(), Error> {
-        self.append_pair(value)
-    }
-
-    fn serialize_bytes(&mut self, value: &[u8]) -> Result<(), Error> {
-        match str::from_utf8(value) {
-            Ok(value) => self.append_pair(value),
-            Err(err) => Err(Error::Utf8(err)),
-        }
-    }
-
-    fn serialize_unit(&mut self) -> Result<(), Error> {
-        Err(Error::unsupported_value())
-    }
-
-    fn serialize_unit_struct(&mut self,
-                             name: &'static str)
-                             -> Result<(), Error> {
-        self.append_pair(name)
-    }
-
-    fn serialize_unit_variant(&mut self,
-                              _name: &'static str,
-                              _variant_index: usize,
-                              variant: &'static str)
-                              -> Result<(), Error> {
-        self.append_pair(variant)
-    }
-
-    fn serialize_newtype_struct<T>(&mut self,
-                                   _name: &'static str,
-                                   value: T)
-                                   -> Result<(), Error>
-        where T: Serialize,
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_newtype_variant<T>(&mut self,
-                                    _name: &'static str,
-                                    _variant_index: usize,
-                                    _variant: &'static str,
-                                    _value: T)
-                                    -> Result<(), Error>
-        where T: Serialize,
-    {
-        Err(Error::unsupported_value())
-    }
-
-    fn serialize_none(&mut self) -> Result<(), Error> {
-        if let Some(_) = self.key.take() {
-            Ok(())
-        } else {
-            Err(Error::no_key())
-        }
-    }
-
-    fn serialize_some<T>(&mut self, value: T) -> Result<(), Error>
-        where T: Serialize,
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_seq(&mut self, _len: Option<usize>) -> Result<(), Error> {
-        Err(Error::unsupported_value())
-    }
-
-    fn serialize_seq_elt<T>(&mut self,
-                            _state: &mut (),
-                            _value: T)
-                            -> Result<(), Error>
-        where T: Serialize,
-    {
-        Err(Error::unsupported_value())
-    }
-
-    fn serialize_seq_end(&mut self, _state: ()) -> Result<(), Error> {
-        Err(Error::unsupported_value())
-    }
-
-    fn serialize_seq_fixed_size(&mut self, _size: usize) -> Result<(), Error> {
-        Err(Error::unsupported_value())
-    }
-
-    fn serialize_tuple(&mut self, _len: usize) -> Result<(), Error> {
-        Err(Error::unsupported_value())
-    }
-
-    fn serialize_tuple_elt<T>(&mut self,
-                              _state: &mut (),
-                              _value: T)
-                              -> Result<(), Error>
-        where T: Serialize,
-    {
-        Err(Error::unsupported_value())
-    }
-
-    fn serialize_tuple_end(&mut self, _state: ()) -> Result<(), Error> {
-        Err(Error::unsupported_value())
-    }
-
-    fn serialize_tuple_struct(&mut self,
-                              _name: &'static str,
-                              _len: usize)
-                              -> Result<(), Error> {
-        Err(Error::unsupported_value())
-    }
-
-    fn serialize_tuple_struct_elt<T>(&mut self,
-                                     _state: &mut (),
-                                     _value: T)
-                                     -> Result<(), Error>
-        where T: Serialize,
-    {
-        Err(Error::unsupported_value())
-    }
-
-    fn serialize_tuple_struct_end(&mut self, _state: ()) -> Result<(), Error> {
-        Err(Error::unsupported_value())
-    }
-
-    fn serialize_tuple_variant(&mut self,
-                               _name: &'static str,
-                               _variant_index: usize,
-                               _variant: &'static str,
-                               _len: usize)
-                               -> Result<(), Error> {
-        Err(Error::unsupported_value())
-    }
-
-    fn serialize_tuple_variant_elt<T>(&mut self,
-                                      _state: &mut (),
-                                      _value: T)
-                                      -> Result<(), Error>
-        where T: Serialize,
-    {
-        Err(Error::unsupported_value())
-    }
-
-    fn serialize_tuple_variant_end(&mut self, _state: ()) -> Result<(), Error> {
-        Err(Error::unsupported_value())
-    }
-
-    fn serialize_map(&mut self, _len: Option<usize>) -> Result<(), Error> {
-        Err(Error::unsupported_value())
-    }
-
-    fn serialize_map_key<T>(&mut self,
-                            _state: &mut (),
-                            _key: T)
-                            -> Result<(), Error>
-        where T: Serialize,
-    {
-        Err(Error::unsupported_value())
-    }
-
-    fn serialize_map_value<T>(&mut self,
-                              _state: &mut (),
-                              _value: T)
-                              -> Result<(), Error>
-        where T: Serialize,
-    {
-        Err(Error::unsupported_value())
-    }
-
-    fn serialize_map_end(&mut self, _state: ()) -> Result<(), Error> {
-        Err(Error::unsupported_value())
-    }
-
-    fn serialize_struct(&mut self,
-                        _name: &'static str,
-                        _len: usize)
-                        -> Result<(), Error> {
-        Err(Error::unsupported_value())
-    }
-
-    fn serialize_struct_elt<T>(&mut self,
-                               _state: &mut (),
-                               _key: &'static str,
-                               _value: T)
-                               -> Result<(), Error>
-        where T: Serialize,
-    {
-        Err(Error::unsupported_value())
-    }
-
-    fn serialize_struct_end(&mut self, _state: ()) -> Result<(), Error> {
-        Err(Error::unsupported_value())
-    }
-
-    fn serialize_struct_variant(&mut self,
-                                _name: &'static str,
-                                _variant_index: usize,
-                                _variant: &'static str,
-                                _len: usize)
-                                -> Result<(), Error> {
-        Err(Error::unsupported_value())
-    }
-    fn serialize_struct_variant_elt<T>(&mut self,
-                                       _state: &mut (),
-                                       _key: &'static str,
-                                       _value: T)
-                                       -> Result<(), Error> {
-        Err(Error::unsupported_value())
-    }
-
-    fn serialize_struct_variant_end(&mut self,
-                                    _state: ())
-                                    -> Result<(), Error> {
-        Err(Error::unsupported_value())
-    }
-}
-
-impl Error {
-    fn no_key() -> Self {
-        Error::Custom("tried to serialize a value before serializing key"
-            .into())
-    }
-
-    fn unsupported_value() -> Self {
         Error::Custom("unsupported value".into())
     }
 }