Reformat with rustfmt

5 files changed, 411 insertions, 396 deletions

diff --git a/src/de.rs b/src/de.rs
index 0f3cb78..42c1f04 100644
--- a/src/de.rs
+++ b/src/de.rs
@@ -1,13 +1,13 @@
 //! Deserialization support for the `application/x-www-form-urlencoded` format.
 
 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;
 
-pub use serde::de::value::Error;
-
 /// Deserializes a `application/x-wwww-url-encoded` value from a `&[u8]`.
 ///
 /// ```
@@ -56,8 +56,10 @@ 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>, Cow<'a, str>, Cow<'a, str>, Error>,
+    inner: MapDeserializer<UrlEncodedParse<'a>,
+                           Cow<'a, str>,
+                           Cow<'a, str>,
+                           Error>,
 }
 
 impl<'a> Deserializer<'a> {
@@ -67,38 +69,36 @@ impl<'a> Deserializer<'a> {
     }
 }
 
-impl<'a> de::Deserializer for Deserializer<'a>
-{
+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>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
         self.deserialize_map(visitor)
     }
 
-    fn deserialize_map<V>(
-            &mut self, mut visitor: V)
-            -> Result<V::Value, Self::Error>
+    fn deserialize_map<V>(&mut self,
+                          mut visitor: V)
+                          -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
         visitor.visit_map(&mut self.inner)
     }
 
-    fn deserialize_seq<V>(
-            &mut self, mut visitor: V)
-            -> Result<V::Value, Self::Error>
+    fn deserialize_seq<V>(&mut self,
+                          mut visitor: V)
+                          -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
         visitor.visit_seq(&mut self.inner)
     }
 
-    fn deserialize_seq_fixed_size<V>(
-            &mut self, _len: usize, mut visitor: V)
-            -> Result<V::Value, Self::Error>
-        where V: de::Visitor
+    fn deserialize_seq_fixed_size<V>(&mut self,
+                                     _len: usize,
+                                     mut visitor: V)
+                                     -> Result<V::Value, Self::Error>
+        where V: de::Visitor,
     {
         visitor.visit_seq(&mut self.inner)
     }
diff --git a/src/ser/key.rs b/src/ser/key.rs
index a26c563..0e5f7a6 100644
--- a/src/ser/key.rs
+++ b/src/ser/key.rs
@@ -1,5 +1,6 @@
-use serde::{Serialize, Serializer};
+
 use ser::Error;
+use serde::{Serialize, Serializer};
 use std::borrow::Cow;
 use std::str;
 
@@ -11,7 +12,7 @@ impl<'key> MapKeySerializer<'key> {
     }
 
     fn set_key<T>(&mut self, key: T) -> Result<(), Error>
-        where T: Into<Cow<'static, str>>
+        where T: Into<Cow<'static, str>>,
     {
         *self.0 = Some(key.into());
         Ok(())
@@ -99,37 +100,36 @@ impl<'key> Serializer for MapKeySerializer<'key> {
         Err(Error::unsupported_key())
     }
 
-    fn serialize_unit_struct(
-            &mut self, name: &'static str)
-            -> Result<(), Error> {
+    fn serialize_unit_struct(&mut self,
+                             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> {
+    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
+    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
+    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())
     }
@@ -139,7 +139,7 @@ impl<'key> Serializer for MapKeySerializer<'key> {
     }
 
     fn serialize_some<T>(&mut self, _value: T) -> Result<(), Error>
-        where T: Serialize
+        where T: Serialize,
     {
         Err(Error::unsupported_key())
     }
@@ -148,10 +148,11 @@ impl<'key> Serializer for MapKeySerializer<'key> {
         Err(Error::unsupported_key())
     }
 
-    fn serialize_seq_elt<T>(
-            &mut self, _state: &mut (), _value: T)
-            -> Result<(), Error>
-        where T: Serialize
+    fn serialize_seq_elt<T>(&mut self,
+                            _state: &mut (),
+                            _value: T)
+                            -> Result<(), Error>
+        where T: Serialize,
     {
         Err(Error::unsupported_key())
     }
@@ -168,10 +169,11 @@ impl<'key> Serializer for MapKeySerializer<'key> {
         Err(Error::unsupported_key())
     }
 
-    fn serialize_tuple_elt<T>(
-            &mut self, _state: &mut (), _value: T)
-            -> Result<(), Error>
-        where T: Serialize
+    fn serialize_tuple_elt<T>(&mut self,
+                              _state: &mut (),
+                              _value: T)
+                              -> Result<(), Error>
+        where T: Serialize,
     {
         Err(Error::unsupported_key())
     }
@@ -180,16 +182,18 @@ impl<'key> Serializer for MapKeySerializer<'key> {
         Err(Error::unsupported_key())
     }
 
-    fn serialize_tuple_struct(
-            &mut self, _name: &'static str, _len: usize)
-            -> Result<(), Error> {
+    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
+    fn serialize_tuple_struct_elt<T>(&mut self,
+                                     _state: &mut (),
+                                     _value: T)
+                                     -> Result<(), Error>
+        where T: Serialize,
     {
         Err(Error::unsupported_key())
     }
@@ -198,20 +202,20 @@ impl<'key> Serializer for MapKeySerializer<'key> {
         Err(Error::unsupported_key())
     }
 
-    fn serialize_tuple_variant(
-            &mut self,
-            _name: &'static str,
-            _variant_index: usize,
-            _variant: &'static str,
-            _len: usize)
-            -> Result<(), Error> {
+    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
+    fn serialize_tuple_variant_elt<T>(&mut self,
+                                      _state: &mut (),
+                                      _value: T)
+                                      -> Result<(), Error>
+        where T: Serialize,
     {
         Err(Error::unsupported_key())
     }
@@ -224,18 +228,20 @@ impl<'key> Serializer for MapKeySerializer<'key> {
         Err(Error::unsupported_key())
     }
 
-    fn serialize_map_key<T>(
-            &mut self, _state: &mut (), _key: T)
-            -> Result<(), Error>
-        where T: Serialize
+    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
+    fn serialize_map_value<T>(&mut self,
+                              _state: &mut (),
+                              _value: T)
+                              -> Result<(), Error>
+        where T: Serialize,
     {
         Err(Error::unsupported_key())
     }
@@ -244,16 +250,19 @@ impl<'key> Serializer for MapKeySerializer<'key> {
         Err(Error::unsupported_key())
     }
 
-    fn serialize_struct(
-            &mut self, _name: &'static str, _len: usize)
-            -> Result<(), Error> {
+    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
+    fn serialize_struct_elt<T>(&mut self,
+                               _state: &mut (),
+                               _key: &'static str,
+                               _value: T)
+                               -> Result<(), Error>
+        where T: Serialize,
     {
         Err(Error::unsupported_key())
     }
@@ -262,25 +271,26 @@ impl<'key> Serializer for MapKeySerializer<'key> {
         Err(Error::unsupported_key())
     }
 
-    fn serialize_struct_variant(
-            &mut self,
-            _name: &'static str,
-            _variant_index: usize,
-            _variant: &'static str,
-            _len: usize)
-            -> Result<(), Error> {
+    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> {
+    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> {
+    fn serialize_struct_variant_end(&mut self,
+                                    _state: ())
+                                    -> Result<(), Error> {
         Err(Error::unsupported_key())
     }
 }
diff --git a/src/ser/mod.rs b/src/ser/mod.rs
index f04c956..00c0540 100644
--- a/src/ser/mod.rs
+++ b/src/ser/mod.rs
@@ -30,7 +30,7 @@ pub fn to_string<T: ser::Serialize>(input: &T) -> Result<String, Error> {
     let mut output = String::new();
     {
         let mut urlencoder = UrlEncodedSerializer::new(&mut output);
-        try!(input.serialize(&mut Serializer::new(&mut urlencoder)));
+        input.serialize(&mut Serializer::new(&mut urlencoder))?;
     }
     Ok(output)
 }
@@ -45,7 +45,7 @@ pub fn to_string<T: ser::Serialize>(input: &T) -> Result<String, Error> {
 ///
 /// * Newtype structs defer to their inner values.
 pub struct Serializer<'output, T: 'output + UrlEncodedTarget> {
-    urlencoder: &'output mut UrlEncodedSerializer<T>
+    urlencoder: &'output mut UrlEncodedSerializer<T>,
 }
 
 impl<'output, T: 'output + UrlEncodedTarget> Serializer<'output, T> {
@@ -85,7 +85,8 @@ 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::InvalidValue(_) => None,
+            Error::Custom(_) |
+            Error::InvalidValue(_) => None,
             Error::Utf8(ref err) => Some(err),
         }
     }
@@ -123,7 +124,7 @@ pub struct TupleVariantState {
 
 /// State used when serializing maps.
 pub struct MapState {
-    key: Option<Cow<'static, str>>
+    key: Option<Cow<'static, str>>,
 }
 
 /// State used when serializing structs.
@@ -137,7 +138,7 @@ pub struct StructVariantState {
 }
 
 impl<'output, Target> ser::Serializer for Serializer<'output, Target>
-    where Target: 'output + UrlEncodedTarget
+    where Target: 'output + UrlEncodedTarget,
 {
     type Error = Error;
 
@@ -248,40 +249,39 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
     }
 
     /// Returns an error.
-    fn serialize_unit_struct(
-            &mut self, _name: &'static str)
-            -> Result<(), Error> {
+    fn serialize_unit_struct(&mut self,
+                             _name: &'static str)
+                             -> Result<(), Error> {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_unit_variant(
-            &mut self,
-            _name: &'static str,
-            _variant_index: usize,
-            _variant: &'static str)
-            -> Result<(), Error> {
+    fn serialize_unit_variant(&mut self,
+                              _name: &'static str,
+                              _variant_index: usize,
+                              _variant: &'static str)
+                              -> Result<(), Error> {
         Err(Error::top_level())
     }
 
     /// Serializes the inner value, ignoring the newtype name.
-    fn serialize_newtype_struct<T>(
-            &mut self, _name: &'static str, value: T)
-            -> Result<(), Error>
-        where T: ser::Serialize
+    fn serialize_newtype_struct<T>(&mut self,
+                                   _name: &'static str,
+                                   value: T)
+                                   -> Result<(), Error>
+        where T: ser::Serialize,
     {
         value.serialize(self)
     }
 
     /// Returns an error.
-    fn serialize_newtype_variant<T>(
-            &mut self,                                    
-            _name: &'static str,                                    
-            _variant_index: usize,                                    
-            _variant: &'static str,                                    
-            _value: T)                                    
-            -> Result<(), Error>
-        where T: ser::Serialize
+    fn serialize_newtype_variant<T>(&mut self,
+                                    _name: &'static str,
+                                    _variant_index: usize,
+                                    _variant: &'static str,
+                                    _value: T)
+                                    -> Result<(), Error>
+        where T: ser::Serialize,
     {
         Err(Error::top_level())
     }
@@ -293,23 +293,24 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
 
     /// Returns an error.
     fn serialize_some<T>(&mut self, value: T) -> Result<(), Error>
-        where T: ser::Serialize
+        where T: ser::Serialize,
     {
         value.serialize(self)
     }
 
     /// Begins to serialize a sequence, given length (if any) is ignored.
-    fn serialize_seq(
-            &mut self, _len: Option<usize>)
-            -> Result<SeqState, Error> {
+    fn serialize_seq(&mut self,
+                     _len: Option<usize>)
+                     -> Result<SeqState, Error> {
         Ok(SeqState { _state: () })
     }
 
     /// Serializes a sequence element.
-    fn serialize_seq_elt<T>(
-            &mut self, _state: &mut SeqState, value: T)
-            -> Result<(), Error>
-        where T: ser::Serialize
+    fn serialize_seq_elt<T>(&mut self,
+                            _state: &mut SeqState,
+                            value: T)
+                            -> Result<(), Error>
+        where T: ser::Serialize,
     {
         value.serialize(&mut pair::PairSerializer::new(self.urlencoder))
     }
@@ -320,9 +321,9 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
     }
 
     /// Begins to serialize a sequence, given length is ignored.
-    fn serialize_seq_fixed_size(
-            &mut self, _length: usize)
-            -> Result<SeqState, Error> {
+    fn serialize_seq_fixed_size(&mut self,
+                                _length: usize)
+                                -> Result<SeqState, Error> {
         Ok(SeqState { _state: () })
     }
 
@@ -332,10 +333,11 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
     }
 
     /// Returns an error.
-    fn serialize_tuple_elt<T>(
-            &mut self, _state: &mut TupleState, _value: T)
-            -> Result<(), Error>
-        where T: ser::Serialize
+    fn serialize_tuple_elt<T>(&mut self,
+                              _state: &mut TupleState,
+                              _value: T)
+                              -> Result<(), Error>
+        where T: ser::Serialize,
     {
         Err(Error::top_level())
     }
@@ -346,80 +348,83 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
     }
 
     /// Returns an error.
-    fn serialize_tuple_struct(
-            &mut self, _name: &'static str, _len: usize)
-            -> Result<TupleStructState, Error> {
+    fn serialize_tuple_struct(&mut self,
+                              _name: &'static str,
+                              _len: usize)
+                              -> Result<TupleStructState, Error> {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_tuple_struct_elt<T>(
-            &mut self, _state: &mut TupleStructState, _value: T)
-            -> Result<(), Error>
-        where T: ser::Serialize
+    fn serialize_tuple_struct_elt<T>(&mut self,
+                                     _state: &mut TupleStructState,
+                                     _value: T)
+                                     -> Result<(), Error>
+        where T: ser::Serialize,
     {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_tuple_struct_end(
-            &mut self, _state: TupleStructState)
-            -> Result<(), Error>
-    {
+    fn serialize_tuple_struct_end(&mut 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> {
+    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
+    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> {
+    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> {
+    fn serialize_map(&mut self,
+                     _len: Option<usize>)
+                     -> Result<MapState, Error> {
         Ok(MapState { key: None })
     }
 
     /// Serializes a map key.
-    fn serialize_map_key<T>(
-            &mut self, state: &mut MapState, key: T)
-            -> Result<(), Error>
-        where T: ser::Serialize
+    fn serialize_map_key<T>(&mut 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
+    fn serialize_map_value<T>(&mut self,
+                              state: &mut MapState,
+                              value: T)
+                              -> Result<(), Error>
+        where T: ser::Serialize,
     {
         let mut value_serializer =
-            try!(value::ValueSerializer::new(&mut state.key, self.urlencoder));
+            value::ValueSerializer::new(&mut state.key, self.urlencoder)?;
         value.serialize(&mut value_serializer)
     }
 
@@ -429,20 +434,20 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
     }
 
     /// Begins to serialize a struct, given length is ignored.
-    fn serialize_struct(
-            &mut self, _name: &'static str, _len: usize)
-            -> Result<StructState, Error> {
+    fn serialize_struct(&mut self,
+                        _name: &'static str,
+                        _len: usize)
+                        -> Result<StructState, Error> {
         Ok(StructState { _state: () })
     }
 
     /// Serializes a struct element.
-    fn serialize_struct_elt<T>(
-            &mut self,
-            _state: &mut StructState,
-            key: &'static str,
-            value: T)
-            -> Result<(), Error>
-        where T: ser::Serialize
+    fn serialize_struct_elt<T>(&mut self,
+                               _state: &mut StructState,
+                               key: &'static str,
+                               value: T)
+                               -> Result<(), Error>
+        where T: ser::Serialize,
     {
         let mut key = Some(key.into());
         let mut value_serializer =
@@ -451,43 +456,42 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
     }
 
     /// Finishes serializing a struct.
-    fn serialize_struct_end(&mut self, _state: StructState)
+    fn serialize_struct_end(&mut self,
+                            _state: StructState)
                             -> Result<(), Error> {
         Ok(())
     }
 
     /// Returns an error.
-    fn serialize_struct_variant(
-            &mut self,
-            _name: &'static str,
-            _variant_index: usize,
-            _variant: &'static str,
-            _len: usize)
-            -> Result<StructVariantState, Error> {
+    fn serialize_struct_variant(&mut self,
+                                _name: &'static str,
+                                _variant_index: usize,
+                                _variant: &'static str,
+                                _len: usize)
+                                -> Result<StructVariantState, Error> {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_struct_variant_elt<T>(
-            &mut self,
-            _state: &mut StructVariantState,
-            _key: &'static str,
-            _value: T)
-            -> Result<(), Error> {
+    fn serialize_struct_variant_elt<T>(&mut self,
+                                       _state: &mut StructVariantState,
+                                       _key: &'static str,
+                                       _value: T)
+                                       -> Result<(), Error> {
         Err(Error::top_level())
     }
 
     /// Returns an error.
-    fn serialize_struct_variant_end(
-            &mut self, _state: StructVariantState)
-            -> Result<(), Error> {
+    fn serialize_struct_variant_end(&mut self,
+                                    _state: StructVariantState)
+                                    -> Result<(), Error> {
         Err(Error::top_level())
     }
 }
 
 impl Error {
     fn top_level() -> Self {
-        Error::Custom(
-            "top-level serializer supports only maps and structs".into())
+        Error::Custom("top-level serializer supports only maps and structs"
+            .into())
     }
 }
diff --git a/src/ser/pair.rs b/src/ser/pair.rs
index 6dfed3d..36eda51 100644
--- a/src/ser/pair.rs
+++ b/src/ser/pair.rs
@@ -8,11 +8,10 @@ pub struct PairSerializer<'target, Target>(
     where Target: 'target + form_urlencoded::Target;
 
 impl<'target, Target> PairSerializer<'target, Target>
-    where Target: 'target + form_urlencoded::Target
+    where Target: 'target + form_urlencoded::Target,
 {
-    pub fn new(
-            serializer: &'target mut form_urlencoded::Serializer<Target>)
-            -> Self {
+    pub fn new(serializer: &'target mut form_urlencoded::Serializer<Target>)
+               -> Self {
         PairSerializer(serializer)
     }
 }
@@ -21,7 +20,7 @@ pub struct TupleState(Option<Option<Cow<'static, str>>>);
 pub struct TupleStructState(TupleState);
 
 impl<'target, Target> Serializer for PairSerializer<'target, Target>
-    where Target: 'target + form_urlencoded::Target
+    where Target: 'target + form_urlencoded::Target,
 {
     type Error = Error;
     type SeqState = ();
@@ -100,37 +99,36 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target>
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_unit_struct(
-            &mut self, _name: &'static str)
-            -> Result<(), Error> {
+    fn serialize_unit_struct(&mut 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)
-            -> Result<(), Error> {
+    fn serialize_unit_variant(&mut self,
+                              _name: &'static str,
+                              _variant_index: usize,
+                              _variant: &'static str)
+                              -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_newtype_struct<T>(
-            &mut self, _name: &'static str, value: T)
-            -> Result<(), Error>
-        where T: Serialize
+    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
+    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_pair())
     }
@@ -140,19 +138,20 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target>
     }
 
     fn serialize_some<T>(&mut self, value: T) -> Result<(), Error>
-        where T: Serialize
+        where T: Serialize,
     {
         value.serialize(self)
     }
 
-    fn serialize_seq(&mut self, _len: Option<usize>)
-                     -> Result<(), Error> {
+    fn serialize_seq(&mut self, _len: Option<usize>) -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_seq_elt<T>(&mut self, _state: &mut (), _value: T)
+    fn serialize_seq_elt<T>(&mut self,
+                            _state: &mut (),
+                            _value: T)
                             -> Result<(), Error>
-        where T: Serialize
+        where T: Serialize,
     {
         Err(Error::unsupported_pair())
     }
@@ -161,8 +160,7 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target>
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_seq_fixed_size(&mut self, _size: usize)
-                                -> Result<(), Error> {
+    fn serialize_seq_fixed_size(&mut self, _size: usize) -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
@@ -174,10 +172,11 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target>
         }
     }
 
-    fn serialize_tuple_elt<T>(
-            &mut self, state: &mut TupleState, value: T)
-            -> Result<(), Error>
-        where T: Serialize
+    fn serialize_tuple_elt<T>(&mut self,
+                              state: &mut TupleState,
+                              value: T)
+                              -> Result<(), Error>
+        where T: Serialize,
     {
         match state.0.take() {
             None => {
@@ -185,7 +184,7 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target>
                 {
                     let mut key_serializer =
                         key::MapKeySerializer::new(&mut key);
-                    try!(value.serialize(&mut key_serializer));
+                    value.serialize(&mut key_serializer)?;
                 }
                 state.0 = Some(key);
                 Ok(())
@@ -194,11 +193,11 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target>
                 {
                     let mut value_serializer =
                         value::ValueSerializer::new(key, &mut self.0).unwrap();
-                    try!(value.serialize(&mut value_serializer));
+                    value.serialize(&mut value_serializer)?;
                 }
                 state.0 = Some(None);
                 Ok(())
-            }
+            },
         }
     }
 
@@ -206,68 +205,68 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target>
         Ok(())
     }
 
-    fn serialize_tuple_struct(
-            &mut self, _name: &'static str, len: usize)
-            -> Result<TupleStructState, Error> {
+    fn serialize_tuple_struct(&mut self,
+                              _name: &'static str,
+                              len: usize)
+                              -> Result<TupleStructState, Error> {
         self.serialize_tuple(len).map(TupleStructState)
     }
 
-    fn serialize_tuple_struct_elt<T>(
-            &mut self, state: &mut TupleStructState, value: T)
-            -> Result<(), Error>
-        where T: Serialize
+    fn serialize_tuple_struct_elt<T>(&mut 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> {
+    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> {
+    fn serialize_tuple_variant(&mut self,
+                               _name: &'static str,
+                               _variant_index: usize,
+                               _variant: &'static str,
+                               _len: usize)
+                               -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_tuple_variant_elt<T>(
-            &mut self, _state: &mut (), _value: T)
-            -> Result<(), Error>
-        where T: Serialize
+    fn serialize_tuple_variant_elt<T>(&mut self,
+                                      _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_tuple_variant_end(&mut self, _state: ()) -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_map(
-            &mut self, _len: Option<usize>)
-            -> Result<(), Error> {
+    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
+    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
+    fn serialize_map_value<T>(&mut self,
+                              _state: &mut (),
+                              _value: T)
+                              -> Result<(), Error>
+        where T: Serialize,
     {
         Err(Error::unsupported_pair())
     }
@@ -276,54 +275,51 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target>
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_struct(&mut self, _name: &'static str, _len: usize)
+    fn serialize_struct(&mut self,
+                        _name: &'static str,
+                        _len: usize)
                         -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 
-    fn serialize_struct_elt<T>(
-            &mut self,
-            _state: &mut (),
-            _key: &'static str,
-            _value: T)
-            -> Result<(), Error>
-        where T: Serialize
+    fn serialize_struct_elt<T>(&mut 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> {
+    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> {
+    fn serialize_struct_variant(&mut self,
+                                _name: &'static str,
+                                _variant_index: usize,
+                                _variant: &'static str,
+                                _len: usize)
+                                -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
-    fn serialize_struct_variant_elt<T>(
-            &mut self,
-            _state: &mut (),
-            _key: &'static str,
-            _value: T)
-            -> Result<(), Error> {
+    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> {
+    fn serialize_struct_variant_end(&mut self,
+                                    _state: ())
+                                    -> Result<(), Error> {
         Err(Error::unsupported_pair())
     }
 }
 
-impl Error {    
+impl Error {
     fn unsupported_pair() -> Self {
         Error::Custom("unsupported pair".into())
     }
diff --git a/src/ser/value.rs b/src/ser/value.rs
index d017242..fcaf0f4 100644
--- a/src/ser/value.rs
+++ b/src/ser/value.rs
@@ -5,19 +5,18 @@ use std::str;
 use url::form_urlencoded;
 
 pub struct ValueSerializer<'key, 'target, Target>
-    where Target: 'target + form_urlencoded::Target
+    where Target: 'target + form_urlencoded::Target,
 {
     key: &'key mut Option<Cow<'static, str>>,
-    serializer: &'target mut form_urlencoded::Serializer<Target>
+    serializer: &'target mut form_urlencoded::Serializer<Target>,
 }
 
 impl<'key, 'target, Target> ValueSerializer<'key, 'target, Target>
-    where Target: 'target + form_urlencoded::Target
+    where Target: 'target + form_urlencoded::Target,
 {
-    pub fn new(
-            key: &'key mut Option<Cow<'static, str>>,
-            serializer: &'target mut form_urlencoded::Serializer<Target>)
-            -> Result<Self, Error> {
+    pub fn new(key: &'key mut Option<Cow<'static, str>>,
+               serializer: &'target mut form_urlencoded::Serializer<Target>)
+               -> Result<Self, Error> {
         if key.is_some() {
             Ok(ValueSerializer {
                 key: key,
@@ -40,7 +39,7 @@ impl<'key, 'target, Target> ValueSerializer<'key, 'target, Target>
 
 impl<'key, 'target, Target> Serializer
     for ValueSerializer<'key, 'target, Target>
-    where Target: 'target + form_urlencoded::Target
+    where Target: 'target + form_urlencoded::Target,
 {
     type Error = Error;
     type SeqState = ();
@@ -122,37 +121,36 @@ impl<'key, 'target, Target> Serializer
         Err(Error::unsupported_value())
     }
 
-    fn serialize_unit_struct(
-            &mut self, name: &'static str)
-            -> Result<(), Error> {
+    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> {
+    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
+    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
+    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())
     }
@@ -166,7 +164,7 @@ impl<'key, 'target, Target> Serializer
     }
 
     fn serialize_some<T>(&mut self, value: T) -> Result<(), Error>
-        where T: Serialize
+        where T: Serialize,
     {
         value.serialize(self)
     }
@@ -175,10 +173,11 @@ impl<'key, 'target, Target> Serializer
         Err(Error::unsupported_value())
     }
 
-    fn serialize_seq_elt<T>(
-            &mut self, _state: &mut (), _value: T)
-            -> Result<(), Error>
-        where T: Serialize
+    fn serialize_seq_elt<T>(&mut self,
+                            _state: &mut (),
+                            _value: T)
+                            -> Result<(), Error>
+        where T: Serialize,
     {
         Err(Error::unsupported_value())
     }
@@ -195,10 +194,11 @@ impl<'key, 'target, Target> Serializer
         Err(Error::unsupported_value())
     }
 
-    fn serialize_tuple_elt<T>(
-            &mut self, _state: &mut (), _value: T)
-            -> Result<(), Error>
-        where T: Serialize
+    fn serialize_tuple_elt<T>(&mut self,
+                              _state: &mut (),
+                              _value: T)
+                              -> Result<(), Error>
+        where T: Serialize,
     {
         Err(Error::unsupported_value())
     }
@@ -207,16 +207,18 @@ impl<'key, 'target, Target> Serializer
         Err(Error::unsupported_value())
     }
 
-    fn serialize_tuple_struct(
-            &mut self, _name: &'static str, _len: usize)
-            -> Result<(), Error> {
+    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
+    fn serialize_tuple_struct_elt<T>(&mut self,
+                                     _state: &mut (),
+                                     _value: T)
+                                     -> Result<(), Error>
+        where T: Serialize,
     {
         Err(Error::unsupported_value())
     }
@@ -225,20 +227,20 @@ impl<'key, 'target, Target> Serializer
         Err(Error::unsupported_value())
     }
 
-    fn serialize_tuple_variant(
-        &mut self,
-        _name: &'static str,
-        _variant_index: usize,
-        _variant: &'static str,
-        _len: usize)
-        -> Result<(), Error> {
+    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
+    fn serialize_tuple_variant_elt<T>(&mut self,
+                                      _state: &mut (),
+                                      _value: T)
+                                      -> Result<(), Error>
+        where T: Serialize,
     {
         Err(Error::unsupported_value())
     }
@@ -251,18 +253,20 @@ impl<'key, 'target, Target> Serializer
         Err(Error::unsupported_value())
     }
 
-    fn serialize_map_key<T>(
-            &mut self, _state: &mut (), _key: T)
-            -> Result<(), Error>
-        where T: Serialize
+    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
+    fn serialize_map_value<T>(&mut self,
+                              _state: &mut (),
+                              _value: T)
+                              -> Result<(), Error>
+        where T: Serialize,
     {
         Err(Error::unsupported_value())
     }
@@ -271,19 +275,19 @@ impl<'key, 'target, Target> Serializer
         Err(Error::unsupported_value())
     }
 
-    fn serialize_struct(
-            &mut self, _name: &'static str, _len: usize)
-            -> Result<(), Error> {
+    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
+    fn serialize_struct_elt<T>(&mut self,
+                               _state: &mut (),
+                               _key: &'static str,
+                               _value: T)
+                               -> Result<(), Error>
+        where T: Serialize,
     {
         Err(Error::unsupported_value())
     }
@@ -292,32 +296,33 @@ impl<'key, 'target, Target> Serializer
         Err(Error::unsupported_value())
     }
 
-    fn serialize_struct_variant(
-            &mut self,
-            _name: &'static str,
-            _variant_index: usize,
-            _variant: &'static str,
-            _len: usize)
-            -> Result<(), Error> {
+    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> {
+    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> {
+    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())
+        Error::Custom("tried to serialize a value before serializing key"
+            .into())
     }
 
     fn unsupported_value() -> Self {