Run `cargo fmt`

8 files changed, 1098 insertions, 793 deletions

diff --git a/examples/toml2json.rs b/examples/toml2json.rs
index 1ed441a..12c3f1c 100644
--- a/examples/toml2json.rs
+++ b/examples/toml2json.rs
@@ -1,24 +1,24 @@
 #![deny(warnings)]
 
-extern crate toml;
 extern crate serde_json;
+extern crate toml;
 
-use std::fs::File;
 use std::env;
+use std::fs::File;
 use std::io;
 use std::io::prelude::*;
 
-use toml::Value as Toml;
 use serde_json::Value as Json;
+use toml::Value as Toml;
 
 fn main() {
     let mut args = env::args();
     let mut input = String::new();
     if args.len() > 1 {
         let name = args.nth(1).unwrap();
-        File::open(&name).and_then(|mut f| {
-            f.read_to_string(&mut input)
-        }).unwrap();
+        File::open(&name)
+            .and_then(|mut f| f.read_to_string(&mut input))
+            .unwrap();
     } else {
         io::stdin().read_to_string(&mut input).unwrap();
     }
@@ -37,15 +37,14 @@ fn convert(toml: Toml) -> Json {
         Toml::String(s) => Json::String(s),
         Toml::Integer(i) => Json::Number(i.into()),
         Toml::Float(f) => {
-            let n = serde_json::Number::from_f64(f)
-                        .expect("float infinite and nan not allowed");
+            let n = serde_json::Number::from_f64(f).expect("float infinite and nan not allowed");
             Json::Number(n)
         }
         Toml::Boolean(b) => Json::Bool(b),
         Toml::Array(arr) => Json::Array(arr.into_iter().map(convert).collect()),
-        Toml::Table(table) => Json::Object(table.into_iter().map(|(k, v)| {
-            (k, convert(v))
-        }).collect()),
+        Toml::Table(table) => {
+            Json::Object(table.into_iter().map(|(k, v)| (k, convert(v))).collect())
+        }
         Toml::Datetime(dt) => Json::String(dt.to_string()),
     }
 }
diff --git a/src/datetime.rs b/src/datetime.rs
index 3678f58..363160b 100644
--- a/src/datetime.rs
+++ b/src/datetime.rs
@@ -1,6 +1,6 @@
+use std::error;
 use std::fmt;
 use std::str::{self, FromStr};
-use std::error;
 
 use serde::{de, ser};
 
@@ -109,9 +109,7 @@ impl fmt::Display for Offset {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             Offset::Z => write!(f, "Z"),
-            Offset::Custom { hours, minutes } => {
-                write!(f, "{:+03}:{:02}", hours, minutes)
-            }
+            Offset::Custom { hours, minutes } => write!(f, "{:+03}:{:02}", hours, minutes),
         }
     }
 }
@@ -127,7 +125,7 @@ impl FromStr for Datetime {
         // 0000-00-00
         // 00:00:00.00
         if date.len() < 3 {
-            return Err(DatetimeParseError { _private: () })
+            return Err(DatetimeParseError { _private: () });
         }
         let mut offset_allowed = true;
         let mut chars = date.chars();
@@ -165,19 +163,19 @@ impl FromStr for Datetime {
             };
 
             if date.month < 1 || date.month > 12 {
-                return Err(DatetimeParseError { _private: () })
+                return Err(DatetimeParseError { _private: () });
             }
             if date.day < 1 || date.day > 31 {
-                return Err(DatetimeParseError { _private: () })
+                return Err(DatetimeParseError { _private: () });
             }
 
             Some(date)
         };
 
         // Next parse the "partial-time" if available
-        let partial_time = if full_date.is_some() &&
-                              (chars.clone().next() == Some('T')
-                              || chars.clone().next() == Some(' ')) {
+        let partial_time = if full_date.is_some()
+            && (chars.clone().next() == Some('T') || chars.clone().next() == Some(' '))
+        {
             chars.next();
             true
         } else {
@@ -208,7 +206,7 @@ impl FromStr for Datetime {
                 let mut end = whole.len();
                 for (i, byte) in whole.bytes().enumerate() {
                     match byte {
-                        b'0' ... b'9' => {
+                        b'0'...b'9' => {
                             if i < 9 {
                                 let p = 10_u32.pow(8 - i as u32);
                                 nanosecond += p * (byte - b'0') as u32;
@@ -221,7 +219,7 @@ impl FromStr for Datetime {
                     }
                 }
                 if end == 0 {
-                    return Err(DatetimeParseError { _private: () })
+                    return Err(DatetimeParseError { _private: () });
                 }
                 chars = whole[end..].chars();
             }
@@ -234,16 +232,16 @@ impl FromStr for Datetime {
             };
 
             if time.hour > 24 {
-                return Err(DatetimeParseError { _private: () })
+                return Err(DatetimeParseError { _private: () });
             }
             if time.minute > 59 {
-                return Err(DatetimeParseError { _private: () })
+                return Err(DatetimeParseError { _private: () });
             }
             if time.second > 59 {
-                return Err(DatetimeParseError { _private: () })
+                return Err(DatetimeParseError { _private: () });
             }
             if time.nanosecond > 999_999_999 {
-                return Err(DatetimeParseError { _private: () })
+                return Err(DatetimeParseError { _private: () });
             }
 
             Some(time)
@@ -288,7 +286,7 @@ impl FromStr for Datetime {
         // Return an error if we didn't hit eof, otherwise return our parsed
         // date
         if chars.next().is_some() {
-            return Err(DatetimeParseError { _private: () })
+            return Err(DatetimeParseError { _private: () });
         }
 
         Ok(Datetime {
@@ -308,7 +306,8 @@ fn digit(chars: &mut str::Chars) -> Result<u8, DatetimeParseError> {
 
 impl ser::Serialize for Datetime {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where S: ser::Serializer
+    where
+        S: ser::Serializer,
     {
         use serde::ser::SerializeStruct;
 
@@ -320,7 +319,8 @@ impl ser::Serialize for Datetime {
 
 impl<'de> de::Deserialize<'de> for Datetime {
     fn deserialize<D>(deserializer: D) -> Result<Datetime, D::Error>
-        where D: de::Deserializer<'de>
+    where
+        D: de::Deserializer<'de>,
     {
         struct DatetimeVisitor;
 
@@ -332,15 +332,15 @@ impl<'de> de::Deserialize<'de> for Datetime {
             }
 
             fn visit_map<V>(self, mut visitor: V) -> Result<Datetime, V::Error>
-                where V: de::MapAccess<'de>
+            where
+                V: de::MapAccess<'de>,
             {
                 let value = visitor.next_key::<DatetimeKey>()?;
                 if value.is_none() {
-                    return Err(de::Error::custom("datetime key not found"))
+                    return Err(de::Error::custom("datetime key not found"));
                 }
                 let v: DatetimeFromString = visitor.next_value()?;
                 Ok(v.value)
-
             }
         }
 
@@ -353,7 +353,8 @@ struct DatetimeKey;
 
 impl<'de> de::Deserialize<'de> for DatetimeKey {
     fn deserialize<D>(deserializer: D) -> Result<DatetimeKey, D::Error>
-        where D: de::Deserializer<'de>
+    where
+        D: de::Deserializer<'de>,
     {
         struct FieldVisitor;
 
@@ -365,7 +366,8 @@ impl<'de> de::Deserialize<'de> for DatetimeKey {
             }
 
             fn visit_str<E>(self, s: &str) -> Result<(), E>
-                where E: de::Error
+            where
+                E: de::Error,
             {
                 if s == FIELD {
                     Ok(())
@@ -386,7 +388,8 @@ pub struct DatetimeFromString {
 
 impl<'de> de::Deserialize<'de> for DatetimeFromString {
     fn deserialize<D>(deserializer: D) -> Result<DatetimeFromString, D::Error>
-        where D: de::Deserializer<'de>
+    where
+        D: de::Deserializer<'de>,
     {
         struct Visitor;
 
@@ -398,7 +401,8 @@ impl<'de> de::Deserialize<'de> for DatetimeFromString {
             }
 
             fn visit_str<E>(self, s: &str) -> Result<DatetimeFromString, E>
-                where E: de::Error,
+            where
+                E: de::Error,
             {
                 match s.parse() {
                     Ok(date) => Ok(DatetimeFromString { value: date }),
diff --git a/src/de.rs b/src/de.rs
index 9334cd3..5f04027 100644
--- a/src/de.rs
+++ b/src/de.rs
@@ -12,19 +12,20 @@ use std::str;
 use std::vec;
 
 use serde::de;
-use serde::de::IntoDeserializer;
 use serde::de::value::BorrowedStrDeserializer;
+use serde::de::IntoDeserializer;
 
-use tokens::{Tokenizer, Token, Error as TokenError, Span};
 use datetime;
 use spanned;
+use tokens::{Error as TokenError, Span, Token, Tokenizer};
 
 /// Deserializes a byte slice into a type.
 ///
 /// This function will attempt to interpret `bytes` as UTF-8 data and then
 /// deserialize `T` from the TOML document provided.
 pub fn from_slice<'de, T>(bytes: &'de [u8]) -> Result<T, Error>
-    where T: de::Deserialize<'de>,
+where
+    T: de::Deserialize<'de>,
 {
     match str::from_utf8(bytes) {
         Ok(s) => from_str(s),
@@ -68,7 +69,8 @@ pub fn from_slice<'de, T>(bytes: &'de [u8]) -> Result<T, Error>
 /// }
 /// ```
 pub fn from_str<'de, T>(s: &'de str) -> Result<T, Error>
-    where T: de::Deserialize<'de>,
+where
+    T: de::Deserialize<'de>,
 {
     let mut d = Deserializer::new(s);
     let ret = T::deserialize(&mut d)?;
@@ -203,9 +205,9 @@ impl<'de, 'b> de::Deserializer<'de> for &'b mut Deserializer<'de> {
     type Error = Error;
 
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
-
         let mut tables = self.tables()?;
 
         visitor.visit_map(MapVisitor {
@@ -226,9 +228,10 @@ impl<'de, 'b> de::Deserializer<'de> for &'b mut Deserializer<'de> {
         self,
         _name: &'static str,
         _variants: &'static [&'static str],
-        visitor: V
+        visitor: V,
     ) -> Result<V::Value, Error>
-        where V: de::Visitor<'de>
+    where
+        V: de::Visitor<'de>,
     {
         let (value, name) = self.string_or_table()?;
         match value.e {
@@ -292,10 +295,11 @@ impl<'de, 'b> de::MapAccess<'de> for MapVisitor<'de, 'b> {
     type Error = Error;
 
     fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
-        where K: de::DeserializeSeed<'de>,
+    where
+        K: de::DeserializeSeed<'de>,
     {
         if self.cur_parent == self.max || self.cur == self.max {
-            return Ok(None)
+            return Ok(None);
         }
 
         loop {
@@ -303,20 +307,24 @@ impl<'de, 'b> de::MapAccess<'de> for MapVisitor<'de, 'b> {
             if let Some((key, value)) = self.values.next() {
                 let ret = seed.deserialize(StrDeserializer::new(key.clone()))?;
                 self.next_value = Some((key, value));
-                return Ok(Some(ret))
+                return Ok(Some(ret));
             }
 
             let next_table = {
                 let prefix = &self.tables[self.cur_parent].header[..self.depth];
-                self.tables[self.cur..self.max].iter().enumerate().find(|&(_, t)| {
-                    if t.values.is_none() {
-                        return false
-                    }
-                    match t.header.get(..self.depth) {
-                        Some(header) => header == prefix,
-                        None => false,
-                    }
-                }).map(|(i, _)| i + self.cur)
+                self.tables[self.cur..self.max]
+                    .iter()
+                    .enumerate()
+                    .find(|&(_, t)| {
+                        if t.values.is_none() {
+                            return false;
+                        }
+                        match t.header.get(..self.depth) {
+                            Some(header) => header == prefix,
+                            None => false,
+                        }
+                    })
+                    .map(|(i, _)| i + self.cur)
             };
 
             let pos = match next_table {
@@ -327,11 +335,12 @@ impl<'de, 'b> de::MapAccess<'de> for MapVisitor<'de, 'b> {
 
             // Test to see if we're duplicating our parent's table, and if so
             // then this is an error in the toml format
-            if self.cur_parent != pos &&
-               self.tables[self.cur_parent].header == self.tables[pos].header {
+            if self.cur_parent != pos
+                && self.tables[self.cur_parent].header == self.tables[pos].header
+            {
                 let at = self.tables[pos].at;
                 let name = self.tables[pos].header.join(".");
-                return Err(self.de.error(at, ErrorKind::DuplicateTable(name)))
+                return Err(self.de.error(at, ErrorKind::DuplicateTable(name)));
             }
 
             let table = &mut self.tables[pos];
@@ -342,42 +351,47 @@ impl<'de, 'b> de::MapAccess<'de> for MapVisitor<'de, 'b> {
             if self.depth != table.header.len() {
                 let key = &table.header[self.depth];
                 let key = seed.deserialize(StrDeserializer::new(key.clone()))?;
-                return Ok(Some(key))
+                return Ok(Some(key));
             }
 
             // Rule out cases like:
             //
             //      [[foo.bar]]
             //      [[foo]]
-            if table.array  {
+            if table.array {
                 let kind = ErrorKind::RedefineAsArray;
-                return Err(self.de.error(table.at, kind))
+                return Err(self.de.error(table.at, kind));
             }
 
-            self.values = table.values.take().expect("Unable to read table values").into_iter();
+            self.values = table
+                .values
+                .take()
+                .expect("Unable to read table values")
+                .into_iter();
         }
     }
 
     fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
-        where V: de::DeserializeSeed<'de>,
+    where
+        V: de::DeserializeSeed<'de>,
     {
         if let Some((k, v)) = self.next_value.take() {
             match seed.deserialize(ValueDeserializer::new(v)) {
                 Ok(v) => return Ok(v),
                 Err(mut e) => {
                     e.add_key_context(&k);
-                    return Err(e)
+                    return Err(e);
                 }
             }
         }
 
-        let array = self.tables[self.cur].array &&
-                    self.depth == self.tables[self.cur].header.len() - 1;
+        let array =
+            self.tables[self.cur].array && self.depth == self.tables[self.cur].header.len() - 1;
         self.cur += 1;
         let res = seed.deserialize(MapVisitor {
             values: Vec::new().into_iter(),
             next_value: None,
-            depth: self.depth + if array {0} else {1},
+            depth: self.depth + if array { 0 } else { 1 },
             cur_parent: self.cur - 1,
             cur: 0,
             max: self.max,
@@ -396,26 +410,30 @@ impl<'de, 'b> de::SeqAccess<'de> for MapVisitor<'de, 'b> {
     type Error = Error;
 
     fn next_element_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
-        where K: de::DeserializeSeed<'de>,
+    where
+        K: de::DeserializeSeed<'de>,
     {
         assert!(self.next_value.is_none());
         assert!(self.values.next().is_none());
 
         if self.cur_parent == self.max {
-            return Ok(None)
+            return Ok(None);
         }
 
         let next = self.tables[..self.max]
             .iter()
             .enumerate()
             .skip(self.cur_parent + 1)
-            .find(|&(_, table)| {
-                table.array && table.header == self.tables[self.cur_parent].header
-            }).map(|p| p.0)
+            .find(|&(_, table)| table.array && table.header == self.tables[self.cur_parent].header)
+            .map(|p| p.0)
             .unwrap_or(self.max);
 
         let ret = seed.deserialize(MapVisitor {
-            values: self.tables[self.cur_parent].values.take().expect("Unable to read table values").into_iter(),
+            values: self.tables[self.cur_parent]
+                .values
+                .take()
+                .expect("Unable to read table values")
+                .into_iter(),
             next_value: None,
             depth: self.depth + 1,
             cur_parent: self.cur_parent,
@@ -434,9 +452,10 @@ impl<'de, 'b> de::Deserializer<'de> for MapVisitor<'de, 'b> {
     type Error = Error;
 
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
-        if self.array  {
+        if self.array {
             visitor.visit_seq(self)
         } else {
             visitor.visit_map(self)
@@ -446,7 +465,8 @@ impl<'de, 'b> de::Deserializer<'de> for MapVisitor<'de, 'b> {
     // `None` is interpreted as a missing field so be sure to implement `Some`
     // as a present field.
     fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         visitor.visit_some(self)
     }
@@ -454,9 +474,10 @@ impl<'de, 'b> de::Deserializer<'de> for MapVisitor<'de, 'b> {
     fn deserialize_newtype_struct<V>(
         self,
         _name: &'static str,
-        visitor: V
+        visitor: V,
     ) -> Result<V::Value, Error>
-        where V: de::Visitor<'de>
+    where
+        V: de::Visitor<'de>,
     {
         visitor.visit_newtype_struct(self)
     }
@@ -474,9 +495,7 @@ struct StrDeserializer<'a> {
 
 impl<'a> StrDeserializer<'a> {
     fn new(key: Cow<'a, str>) -> StrDeserializer<'a> {
-        StrDeserializer {
-            key: key,
-        }
+        StrDeserializer { key: key }
     }
 }
 
@@ -484,7 +503,8 @@ impl<'de> de::Deserializer<'de> for StrDeserializer<'de> {
     type Error = Error;
 
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         match self.key {
             Cow::Borrowed(s) => visitor.visit_borrowed_str(s),
@@ -522,7 +542,8 @@ impl<'de> de::Deserializer<'de> for ValueDeserializer<'de> {
     type Error = Error;
 
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         match self.value.e {
             E::Integer(i) => visitor.visit_i64(i),
@@ -549,25 +570,29 @@ impl<'de> de::Deserializer<'de> for ValueDeserializer<'de> {
         }
     }
 
-    fn deserialize_struct<V>(self,
-                             name: &'static str,
-                             fields: &'static [&'static str],
-                             visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor<'de>,
+    fn deserialize_struct<V>(
+        self,
+        name: &'static str,
+        fields: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Error>
+    where
+        V: de::Visitor<'de>,
     {
         if name == datetime::NAME && fields == &[datetime::FIELD] {
             if let E::Datetime(s) = self.value.e {
                 return visitor.visit_map(DatetimeDeserializer {
                     date: s,
                     visited: false,
-                })
+                });
             }
         }
 
         if self.validate_struct_keys {
             match &self.value.e {
                 &E::InlineTable(ref values) | &E::DottedTable(ref values) => {
-                    let extra_fields = values.iter()
+                    let extra_fields = values
+                        .iter()
                         .filter_map(|key_value| {
                             let (ref key, ref _val) = *key_value;
                             if !fields.contains(&&(**key)) {
@@ -580,7 +605,10 @@ impl<'de> de::Deserializer<'de> for ValueDeserializer<'de> {
 
                     if !extra_fields.is_empty() {
                         return Err(Error::from_kind(ErrorKind::UnexpectedKeys {
-                            keys: extra_fields.iter().map(|k| k.to_string()).collect::<Vec<_>>(),
+                            keys: extra_fields
+                                .iter()
+                                .map(|k| k.to_string())
+                                .collect::<Vec<_>>(),
                             available: fields,
                         }));
                     }
@@ -606,7 +634,8 @@ impl<'de> de::Deserializer<'de> for ValueDeserializer<'de> {
     // `None` is interpreted as a missing field so be sure to implement `Some`
     // as a present field.
     fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         visitor.visit_some(self)
     }
@@ -615,9 +644,10 @@ impl<'de> de::Deserializer<'de> for ValueDeserializer<'de> {
         self,
         _name: &'static str,
         _variants: &'static [&'static str],
-        visitor: V
+        visitor: V,
     ) -> Result<V::Value, Error>
-        where V: de::Visitor<'de>
+    where
+        V: de::Visitor<'de>,
     {
         match self.value.e {
             E::String(val) => visitor.visit_enum(val.into_deserializer()),
@@ -648,9 +678,10 @@ impl<'de> de::Deserializer<'de> for ValueDeserializer<'de> {
     fn deserialize_newtype_struct<V>(
         self,
         _name: &'static str,
-        visitor: V
+        visitor: V,
     ) -> Result<V::Value, Error>
-        where V: de::Visitor<'de>
+    where
+        V: de::Visitor<'de>,
     {
         visitor.visit_newtype_struct(self)
     }
@@ -684,11 +715,14 @@ impl<'de> de::MapAccess<'de> for SpannedDeserializer<'de> {
         K: de::DeserializeSeed<'de>,
     {
         if self.start.is_some() {
-            seed.deserialize(BorrowedStrDeserializer::new(spanned::START)).map(Some)
+            seed.deserialize(BorrowedStrDeserializer::new(spanned::START))
+                .map(Some)
         } else if self.end.is_some() {
-            seed.deserialize(BorrowedStrDeserializer::new(spanned::END)).map(Some)
+            seed.deserialize(BorrowedStrDeserializer::new(spanned::END))
+                .map(Some)
         } else if self.value.is_some() {
-            seed.deserialize(BorrowedStrDeserializer::new(spanned::VALUE)).map(Some)
+            seed.deserialize(BorrowedStrDeserializer::new(spanned::VALUE))
+                .map(Some)
         } else {
             Ok(None)
         }
@@ -700,7 +734,7 @@ impl<'de> de::MapAccess<'de> for SpannedDeserializer<'de> {
     {
         if let Some(start) = self.start.take() {
             seed.deserialize(start.into_deserializer())
-        } else if  let Some(end) = self.end.take() {
+        } else if let Some(end) = self.end.take() {
             seed.deserialize(end.into_deserializer())
         } else if let Some(value) = self.value.take() {
             seed.deserialize(value.into_deserializer())
@@ -719,17 +753,19 @@ impl<'de> de::MapAccess<'de> for DatetimeDeserializer<'de> {
     type Error = Error;
 
     fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
-        where K: de::DeserializeSeed<'de>,
+    where
+        K: de::DeserializeSeed<'de>,
     {
         if self.visited {
-            return Ok(None)
+            return Ok(None);
         }
         self.visited = true;
         seed.deserialize(DatetimeFieldDeserializer).map(Some)
     }
 
     fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
-        where V: de::DeserializeSeed<'de>,
+    where
+        V: de::DeserializeSeed<'de>,
     {
         seed.deserialize(StrDeserializer::new(self.date.into()))
     }
@@ -741,7 +777,8 @@ impl<'de> de::Deserializer<'de> for DatetimeFieldDeserializer {
     type Error = Error;
 
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         visitor.visit_borrowed_str(datetime::FIELD)
     }
@@ -781,7 +818,8 @@ impl<'de> de::MapAccess<'de> for InlineTableDeserializer<'de> {
     type Error = Error;
 
     fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
-        where K: de::DeserializeSeed<'de>,
+    where
+        K: de::DeserializeSeed<'de>,
     {
         let (key, value) = match self.values.next() {
             Some(pair) => pair,
@@ -792,7 +830,8 @@ impl<'de> de::MapAccess<'de> for InlineTableDeserializer<'de> {
     }
 
     fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
-        where V: de::DeserializeSeed<'de>,
+    where
+        V: de::DeserializeSeed<'de>,
     {
         let value = self.next_value.take().expect("Unable to read table values");
         seed.deserialize(ValueDeserializer::new(value))
@@ -998,12 +1037,12 @@ impl<'a> Deserializer<'a> {
         loop {
             self.eat_whitespace()?;
             if self.eat_comment()? {
-                continue
+                continue;
             }
             if self.eat(Token::Newline)? {
-                continue
+                continue;
             }
-            break
+            break;
         }
 
         match self.peek()? {
@@ -1017,9 +1056,7 @@ impl<'a> Deserializer<'a> {
         let start = self.tokens.current();
         self.expect(Token::LeftBracket)?;
         let array = self.eat(Token::LeftBracket)?;
-        let ret = Header::new(self.tokens.clone(),
-                              array,
-                              self.require_newline_after_table);
+        let ret = Header::new(self.tokens.clone(), array, self.require_newline_after_table);
         if self.require_newline_after_table {
             self.tokens.skip_to_newline();
         } else {
@@ -1029,16 +1066,19 @@ impl<'a> Deserializer<'a> {
                         if array {
                             self.eat(Token::RightBracket)?;
                         }
-                        break
+                        break;
                     }
-                    Some((_, Token::Newline)) |
-                    None => break,
+                    Some((_, Token::Newline)) | None => break,
                     _ => {}
                 }
             }
             self.eat_whitespace()?;
         }
-        Ok(Line::Table { at: start, header: ret, array: array })
+        Ok(Line::Table {
+            at: start,
+            header: ret,
+            array: array,
+        })
     }
 
     fn key_value(&mut self) -> Result<Line<'a>, Error> {
@@ -1059,58 +1099,66 @@ impl<'a> Deserializer<'a> {
     fn value(&mut self) -> Result<Value<'a>, Error> {
         let at = self.tokens.current();
         let value = match self.next()? {
-            Some((Span { start, end }, Token::String { val, .. })) => {
-                Value { e: E::String(val), start: start, end: end }
-            }
-            Some((Span { start, end }, Token::Keylike("true"))) => {
-                Value { e: E::Boolean(true), start: start, end: end }
-            }
-            Some((Span { start, end }, Token::Keylike("false"))) => {
-                Value { e: E::Boolean(false), start: start, end: end }
-            }
+            Some((Span { start, end }, Token::String { val, .. })) => Value {
+                e: E::String(val),
+                start: start,
+                end: end,
+            },
+            Some((Span { start, end }, Token::Keylike("true"))) => Value {
+                e: E::Boolean(true),
+                start: start,
+                end: end,
+            },
+            Some((Span { start, end }, Token::Keylike("false"))) => Value {
+                e: E::Boolean(false),
+                start: start,
+                end: end,
+            },
             Some((span, Token::Keylike(key))) => self.number_or_date(span, key)?,
             Some((span, Token::Plus)) => self.number_leading_plus(span)?,
             Some((Span { start, .. }, Token::LeftBrace)) => {
                 self.inline_table().map(|(Span { end, .. }, table)| Value {
                     e: E::InlineTable(table),
                     start: start,
-                    end: end
+                    end: end,
                 })?
             }
             Some((Span { start, .. }, Token::LeftBracket)) => {
                 self.array().map(|(Span { end, .. }, array)| Value {
                     e: E::Array(array),
                     start: start,
-                    end: end
+                    end: end,
                 })?
             }
             Some(token) => {
-                return Err(self.error(at, ErrorKind::Wanted {
-                    expected: "a value",
-                    found: token.1.describe(),
-                }))
+                return Err(self.error(
+                    at,
+                    ErrorKind::Wanted {
+                        expected: "a value",
+                        found: token.1.describe(),
+                    },
+                ))
             }
             None => return Err(self.eof()),
         };
         Ok(value)
     }
 
-    fn number_or_date(&mut self, span: Span, s: &'a str)
-        -> Result<Value<'a>, Error>
-    {
-        if s.contains('T') || (s.len() > 1 && s[1..].contains('-')) &&
-           !s.contains("e-") {
-            self.datetime(span, s, false).map(|(Span { start, end }, d)| Value {
-                e: E::Datetime(d),
-                start: start,
-                end: end
-            })
+    fn number_or_date(&mut self, span: Span, s: &'a str) -> Result<Value<'a>, Error> {
+        if s.contains('T') || (s.len() > 1 && s[1..].contains('-')) && !s.contains("e-") {
+            self.datetime(span, s, false)
+                .map(|(Span { start, end }, d)| Value {
+                    e: E::Datetime(d),
+                    start: start,
+                    end: end,
+                })
         } else if self.eat(Token::Colon)? {
-            self.datetime(span, s, true).map(|(Span { start, end }, d)| Value {
-                e: E::Datetime(d),
-                start: start,
-                end: end
-            })
+            self.datetime(span, s, true)
+                .map(|(Span { start, end }, d)| Value {
+                    e: E::Datetime(d),
+                    start: start,
+                    end: end,
+                })
         } else {
             self.number(span, s)
         }
@@ -1166,7 +1214,11 @@ impl<'a> Deserializer<'a> {
     }
 
     fn number(&mut self, Span { start, end }: Span, s: &'a str) -> Result<Value<'a>, Error> {
-        let to_integer = |f| Value { e: E::Integer(f), start: start, end: end };
+        let to_integer = |f| Value {
+            e: E::Integer(f),
+            start: start,
+            end: end,
+        };
         if s.starts_with("0x") {
             self.integer(&s[2..], 16).map(to_integer)
         } else if s.starts_with("0o") {
@@ -1174,25 +1226,47 @@ impl<'a> Deserializer<'a> {
         } else if s.starts_with("0b") {
             self.integer(&s[2..], 2).map(to_integer)
         } else if s.contains('e') || s.contains('E') {
-            self.float(s, None).map(|f| Value { e: E::Float(f), start: start, end: end })
+            self.float(s, None).map(|f| Value {
+                e: E::Float(f),
+                start: start,
+                end: end,
+            })
         } else if self.eat(Token::Period)? {
             let at = self.tokens.current();
             match self.next()? {
                 Some((Span { start, end }, Token::Keylike(after))) => {
                     self.float(s, Some(after)).map(|f| Value {
-                        e: E::Float(f), start: start, end: end
+                        e: E::Float(f),
+                        start: start,
+                        end: end,
                     })
                 }
                 _ => Err(self.error(at, ErrorKind::NumberInvalid)),
             }
         } else if s == "inf" {
-            Ok(Value { e: E::Float(f64::INFINITY), start: start, end: end })
+            Ok(Value {
+                e: E::Float(f64::INFINITY),
+                start: start,
+                end: end,
+            })
         } else if s == "-inf" {
-            Ok(Value { e: E::Float(f64::NEG_INFINITY), start: start, end: end })
+            Ok(Value {
+                e: E::Float(f64::NEG_INFINITY),
+                start: start,
+                end: end,
+            })
         } else if s == "nan" {
-            Ok(Value { e: E::Float(f64::NAN), start: start, end: end })
+            Ok(Value {
+                e: E::Float(f64::NAN),
+                start: start,
+                end: end,
+            })
         } else if s == "-nan" {
-            Ok(Value { e: E::Float(-f64::NAN), start: start, end: end })
+            Ok(Value {
+                e: E::Float(-f64::NAN),
+                start: start,
+                end: end,
+            })
         } else {
             self.integer(s, 10).map(to_integer)
         }
@@ -1201,9 +1275,13 @@ impl<'a> Deserializer<'a> {
     fn number_leading_plus(&mut self, Span { start, .. }: Span) -> Result<Value<'a>, Error> {
         let start_token = self.tokens.current();
         match self.next()? {
-            Some((Span { end, .. }, Token::Keylike(s))) => {
-                self.number(Span { start: start, end: end }, s)
-            },
+            Some((Span { end, .. }, Token::Keylike(s))) => self.number(
+                Span {
+                    start: start,
+                    end: end,
+                },
+                s,
+            ),
             _ => Err(self.error(start_token, ErrorKind::NumberInvalid)),
         }
     }
@@ -1214,7 +1292,7 @@ impl<'a> Deserializer<'a> {
         let (prefix, suffix) = self.parse_integer(s, allow_sign, allow_leading_zeros, radix)?;
         let start = self.tokens.substr_offset(s);
         if suffix != "" {
-            return Err(self.error(start, ErrorKind::NumberInvalid))
+            return Err(self.error(start, ErrorKind::NumberInvalid));
         }
         i64::from_str_radix(&prefix.replace("_", "").trim_left_matches('+'), radix)
             .map_err(|_e| self.error(start, ErrorKind::NumberInvalid))
@@ -1236,7 +1314,7 @@ impl<'a> Deserializer<'a> {
         for (i, c) in s.char_indices() {
             let at = i + start;
             if i == 0 && (c == '+' || c == '-') && allow_sign {
-                continue
+                continue;
             }
 
             if c == '0' && first {
@@ -1257,20 +1335,19 @@ impl<'a> Deserializer<'a> {
             first = false;
         }
         if first || underscore {
-            return Err(self.error(start, ErrorKind::NumberInvalid))
+            return Err(self.error(start, ErrorKind::NumberInvalid));
         }
         Ok((&s[..end], &s[end..]))
     }
 
-    fn float(&mut self, s: &'a str, after_decimal: Option<&'a str>)
-             -> Result<f64, Error> {
+    fn float(&mut self, s: &'a str, after_decimal: Option<&'a str>) -> Result<f64, Error> {
         let (integral, mut suffix) = self.parse_integer(s, true, false, 10)?;
         let start = self.tokens.substr_offset(integral);
 
         let mut fraction = None;
         if let Some(after) = after_decimal {
             if suffix != "" {
-                return Err(self.error(start, ErrorKind::NumberInvalid))
+                return Err(self.error(start, ErrorKind::NumberInvalid));
             }
             let (a, b) = self.parse_integer(after, false, true, 10)?;
             fraction = Some(a);
@@ -1282,24 +1359,23 @@ impl<'a> Deserializer<'a> {
             let (a, b) = if suffix.len() == 1 {
                 self.eat(Token::Plus)?;
                 match self.next()? {
-                    Some((_, Token::Keylike(s))) => {
-                        self.parse_integer(s, false, false, 10)?
-                    }
+                    Some((_, Token::Keylike(s))) => self.parse_integer(s, false, false, 10)?,
                     _ => return Err(self.error(start, ErrorKind::NumberInvalid)),
                 }
             } else {
                 self.parse_integer(&suffix[1..], true, false, 10)?
             };
             if b != "" {
-                return Err(self.error(start, ErrorKind::NumberInvalid))
+                return Err(self.error(start, ErrorKind::NumberInvalid));
             }
             exponent = Some(a);
         }
 
-        let mut number = integral.trim_left_matches('+')
-                                 .chars()
-                                 .filter(|c| *c != '_')
-                                 .collect::<String>();
+        let mut number = integral
+            .trim_left_matches('+')
+            .chars()
+            .filter(|c| *c != '_')
+            .collect::<String>();
         if let Some(fraction) = fraction {
             number.push_str(".");
             number.extend(fraction.chars().filter(|c| *c != '_'));
@@ -1308,19 +1384,24 @@ impl<'a> Deserializer<'a> {
             number.push_str("E");
             number.extend(exponent.chars().filter(|c| *c != '_'));
         }
-        number.parse().map_err(|_e| {
-            self.error(start, ErrorKind::NumberInvalid)
-        }).and_then(|n: f64| {
-            if n.is_finite() {
-                Ok(n)
-            } else {
-                Err(self.error(start, ErrorKind::NumberInvalid))
-            }
-        })
+        number
+            .parse()
+            .map_err(|_e| self.error(start, ErrorKind::NumberInvalid))
+            .and_then(|n: f64| {
+                if n.is_finite() {
+                    Ok(n)
+                } else {
+                    Err(self.error(start, ErrorKind::NumberInvalid))
+                }
+            })
     }
 
-    fn datetime(&mut self, mut span: Span, date: &'a str, colon_eaten: bool)
-                -> Result<(Span, &'a str), Error> {
+    fn datetime(
+        &mut self,
+        mut span: Span,
+        date: &'a str,
+        colon_eaten: bool,
+    ) -> Result<(Span, &'a str), Error> {
         let start = self.tokens.substr_offset(date);
 
         // Check for space separated date and time.
@@ -1328,8 +1409,8 @@ impl<'a> Deserializer<'a> {
         if let Ok(Some((_, Token::Whitespace(" ")))) = lookahead.next() {
             // Check if hour follows.
             if let Ok(Some((_, Token::Keylike(_)))) = lookahead.next() {
-                self.next()?;  // skip space
-                self.next()?;  // skip keylike hour
+                self.next()?; // skip space
+                self.next()?; // skip keylike hour
             }
         }
 
@@ -1344,7 +1425,7 @@ impl<'a> Deserializer<'a> {
             match self.next()? {
                 Some((Span { end, .. }, Token::Keylike(_))) => {
                     span.end = end;
-                },
+                }
                 _ => return Err(self.error(start, ErrorKind::DateInvalid)),
             }
             // Fractional seconds
@@ -1352,7 +1433,7 @@ impl<'a> Deserializer<'a> {
                 match self.next()? {
                     Some((Span { end, .. }, Token::Keylike(_))) => {
                         span.end = end;
-                    },
+                    }
                     _ => return Err(self.error(start, ErrorKind::DateInvalid)),
                 }
             }
@@ -1362,7 +1443,7 @@ impl<'a> Deserializer<'a> {
                 match self.next()? {
                     Some((Span { end, .. }, Token::Keylike(_))) => {
                         span.end = end;
-                    },
+                    }
                     _ => return Err(self.error(start, ErrorKind::DateInvalid)),
                 }
             }
@@ -1370,7 +1451,7 @@ impl<'a> Deserializer<'a> {
                 match self.next()? {
                     Some((Span { end, .. }, Token::Keylike(_))) => {
                         span.end = end;
-                    },
+                    }
                     _ => return Err(self.error(start, ErrorKind::DateInvalid)),
                 }
             }
@@ -1386,7 +1467,7 @@ impl<'a> Deserializer<'a> {
         let mut ret = Vec::new();
         self.eat_whitespace()?;
         if let Some(span) = self.eat_spanned(Token::RightBrace)? {
-            return Ok((span, ret))
+            return Ok((span, ret));
         }
         loop {
             let key = self.dotted_key()?;
@@ -1398,7 +1479,7 @@ impl<'a> Deserializer<'a> {
 
             self.eat_whitespace()?;
             if let Some(span) = self.eat_spanned(Token::RightBrace)? {
-                return Ok((span, ret))
+                return Ok((span, ret));
             }
             self.expect(Token::Comma)?;
             self.eat_whitespace()?;
@@ -1414,7 +1495,7 @@ impl<'a> Deserializer<'a> {
             loop {
                 me.eat_whitespace()?;
                 if !me.eat(Token::Newline)? && !me.eat_comment()? {
-                    break
+                    break;
                 }
             }
             Ok(())
@@ -1423,19 +1504,19 @@ impl<'a> Deserializer<'a> {
         loop {
             intermediate(self)?;
             if let Some(span) = self.eat_spanned(Token::RightBracket)? {
-                return Ok((span, ret))
+                return Ok((span, ret));
             }
             let at = self.tokens.current();
             let value = self.value()?;
             if let Some(last) = ret.last() {
                 if !value.same_type(last) {
-                    return Err(self.error(at, ErrorKind::MixedArrayType))
+                    return Err(self.error(at, ErrorKind::MixedArrayType));
                 }
             }
             ret.push(value);
             intermediate(self)?;
             if !self.eat(Token::Comma)? {
-                break
+                break;
             }
         }
         intermediate(self)?;
@@ -1444,7 +1525,10 @@ impl<'a> Deserializer<'a> {
     }
 
     fn table_key(&mut self) -> Result<Cow<'a, str>, Error> {
-        self.tokens.table_key().map(|t| t.1).map_err(|e| self.token_error(e))
+        self.tokens
+            .table_key()
+            .map(|t| t.1)
+            .map_err(|e| self.token_error(e))
     }
 
     fn dotted_key(&mut self) -> Result<Vec<Cow<'a, str>>, Error> {
@@ -1483,7 +1567,13 @@ impl<'a> Deserializer<'a> {
             return Ok(());
         }
         match values.iter_mut().find(|&&mut (ref k, _)| *k == key) {
-            Some(&mut (_, Value { e: E::DottedTable(ref mut v), .. })) => {
+            Some(&mut (
+                _,
+                Value {
+                    e: E::DottedTable(ref mut v),
+                    ..
+                },
+            )) => {
                 return self.add_dotted_key(key_parts, value, v);
             }
             Some(&mut (_, Value { start, .. })) => {
@@ -1499,14 +1589,23 @@ impl<'a> Deserializer<'a> {
         };
         values.push((key, table_values));
         let last_i = values.len() - 1;
-        if let (_, Value { e: E::DottedTable(ref mut v), .. }) = values[last_i] {
+        if let (
+            _,
+            Value {
+                e: E::DottedTable(ref mut v),
+                ..
+            },
+        ) = values[last_i]
+        {
             self.add_dotted_key(key_parts, value, v)?;
         }
         Ok(())
     }
 
     fn eat_whitespace(&mut self) -> Result<(), Error> {
-        self.tokens.eat_whitespace().map_err(|e| self.token_error(e))
+        self.tokens
+            .eat_whitespace()
+            .map_err(|e| self.token_error(e))
     }
 
     fn eat_comment(&mut self) -> Result<bool, Error> {
@@ -1514,7 +1613,9 @@ impl<'a> Deserializer<'a> {
     }
 
     fn eat_newline_or_eof(&mut self) -> Result<(), Error> {
-        self.tokens.eat_newline_or_eof().map_err(|e| self.token_error(e))
+        self.tokens
+            .eat_newline_or_eof()
+            .map_err(|e| self.token_error(e))
     }
 
     fn eat(&mut self, expected: Token<'a>) -> Result<bool, Error> {
@@ -1522,15 +1623,21 @@ impl<'a> Deserializer<'a> {
     }
 
     fn eat_spanned(&mut self, expected: Token<'a>) -> Result<Option<Span>, Error> {
-        self.tokens.eat_spanned(expected).map_err(|e| self.token_error(e))
+        self.tokens
+            .eat_spanned(expected)
+            .map_err(|e| self.token_error(e))
     }
 
     fn expect(&mut self, expected: Token<'a>) -> Result<(), Error> {
-        self.tokens.expect(expected).map_err(|e| self.token_error(e))
+        self.tokens
+            .expect(expected)
+            .map_err(|e| self.token_error(e))
     }
 
     fn expect_spanned(&mut self, expected: Token<'a>) -> Result<Span, Error> {
-        self.tokens.expect_spanned(expected).map_err(|e| self.token_error(e))
+        self.tokens
+            .expect_spanned(expected)
+            .map_err(|e| self.token_error(e))
     }
 
     fn next(&mut self) -> Result<Option<(Span, Token<'a>)>, Error> {
@@ -1550,36 +1657,28 @@ impl<'a> Deserializer<'a> {
             TokenError::InvalidCharInString(at, ch) => {
                 self.error(at, ErrorKind::InvalidCharInString(ch))
             }
-            TokenError::InvalidEscape(at, ch) => {
-                self.error(at, ErrorKind::InvalidEscape(ch))
-            }
+            TokenError::InvalidEscape(at, ch) => self.error(at, ErrorKind::InvalidEscape(ch)),
             TokenError::InvalidEscapeValue(at, v) => {
                 self.error(at, ErrorKind::InvalidEscapeValue(v))
             }
-            TokenError::InvalidHexEscape(at, ch) => {
-                self.error(at, ErrorKind::InvalidHexEscape(ch))
-            }
-            TokenError::NewlineInString(at) => {
-                self.error(at, ErrorKind::NewlineInString)
-            }
-            TokenError::Unexpected(at, ch) => {
-                self.error(at, ErrorKind::Unexpected(ch))
-            }
-            TokenError::UnterminatedString(at) => {
-                self.error(at, ErrorKind::UnterminatedString)
-            }
-            TokenError::NewlineInTableKey(at) => {
-                self.error(at, ErrorKind::NewlineInTableKey)
-            }
-            TokenError::Wanted { at, expected, found } => {
-                self.error(at, ErrorKind::Wanted { expected: expected, found: found })
-            }
-            TokenError::EmptyTableKey(at) => {
-                self.error(at, ErrorKind::EmptyTableKey)
-            }
-            TokenError::MultilineStringKey(at) => {
-                self.error(at, ErrorKind::MultilineStringKey)
-            }
+            TokenError::InvalidHexEscape(at, ch) => self.error(at, ErrorKind::InvalidHexEscape(ch)),
+            TokenError::NewlineInString(at) => self.error(at, ErrorKind::NewlineInString),
+            TokenError::Unexpected(at, ch) => self.error(at, ErrorKind::Unexpected(ch)),
+            TokenError::UnterminatedString(at) => self.error(at, ErrorKind::UnterminatedString),
+            TokenError::NewlineInTableKey(at) => self.error(at, ErrorKind::NewlineInTableKey),
+            TokenError::Wanted {
+                at,
+                expected,
+                found,
+            } => self.error(
+                at,
+                ErrorKind::Wanted {
+                    expected: expected,
+                    found: found,
+                },
+            ),
+            TokenError::EmptyTableKey(at) => self.error(at, ErrorKind::EmptyTableKey),
+            TokenError::MultilineStringKey(at) => self.error(at, ErrorKind::MultilineStringKey),
         }
     }
 
@@ -1598,7 +1697,7 @@ impl<'a> Deserializer<'a> {
         let mut cur = 0;
         for (i, line) in self.input.lines().enumerate() {
             if cur + line.len() + 1 > offset {
-                return (i, offset - cur)
+                return (i, offset - cur);
             }
             cur += line.len() + 1;
         }
@@ -1650,26 +1749,28 @@ impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self.inner.kind {
             ErrorKind::UnexpectedEof => "unexpected eof encountered".fmt(f)?,
-            ErrorKind::InvalidCharInString(c) => {
-                write!(f, "invalid character in string: `{}`",
-                       c.escape_default().collect::<String>())?
-            }
-            ErrorKind::InvalidEscape(c) => {
-                write!(f, "invalid escape character in string: `{}`",
-                       c.escape_default().collect::<String>())?
-            }
-            ErrorKind::InvalidHexEscape(c) => {
-                write!(f, "invalid hex escape character in string: `{}`",
-                       c.escape_default().collect::<String>())?
-            }
-            ErrorKind::InvalidEscapeValue(c) => {
-                write!(f, "invalid escape value: `{}`", c)?
-            }
+            ErrorKind::InvalidCharInString(c) => write!(
+                f,
+                "invalid character in string: `{}`",
+                c.escape_default().collect::<String>()
+            )?,
+            ErrorKind::InvalidEscape(c) => write!(
+                f,
+                "invalid escape character in string: `{}`",
+                c.escape_default().collect::<String>()
+            )?,
+            ErrorKind::InvalidHexEscape(c) => write!(
+                f,
+                "invalid hex escape character in string: `{}`",
+                c.escape_default().collect::<String>()
+            )?,
+            ErrorKind::InvalidEscapeValue(c) => write!(f, "invalid escape value: `{}`", c)?,
             ErrorKind::NewlineInString => "newline in string found".fmt(f)?,
-            ErrorKind::Unexpected(ch) => {
-                write!(f, "unexpected character found: `{}`",
-                       ch.escape_default().collect::<String>())?
-            }
+            ErrorKind::Unexpected(ch) => write!(
+                f,
+                "unexpected character found: `{}`",
+                ch.escape_default().collect::<String>()
+            )?,
             ErrorKind::UnterminatedString => "unterminated string".fmt(f)?,
             ErrorKind::NewlineInTableKey => "found newline in table key".fmt(f)?,
             ErrorKind::Wanted { expected, found } => {
@@ -1694,14 +1795,14 @@ impl fmt::Display for Error {
             ErrorKind::DottedKeyInvalidType => {
                 "dotted key attempted to extend non-table type".fmt(f)?
             }
-            ErrorKind::UnexpectedKeys { ref keys, available } => {
-                write!(
-                    f,
-                    "unexpected keys in table: `{:?}`, available keys: `{:?}`",
-                    keys,
-                    available
-                )?
-            }
+            ErrorKind::UnexpectedKeys {
+                ref keys,
+                available,
+            } => write!(
+                f,
+                "unexpected keys in table: `{:?}`, available keys: `{:?}`",
+                keys, available
+            )?,
             ErrorKind::__Nonexhaustive => panic!(),
         }
 
@@ -1762,7 +1863,11 @@ impl de::Error for Error {
 }
 
 enum Line<'a> {
-    Table { at: usize, header: Header<'a>, array: bool },
+    Table {
+        at: usize,
+        header: Header<'a>,
+        array: bool,
+    },
     KeyValue(Vec<Cow<'a, str>>, Value<'a>),
 }
 
@@ -1774,9 +1879,7 @@ struct Header<'a> {
 }
 
 impl<'a> Header<'a> {
-    fn new(tokens: Tokenizer<'a>,
-           array: bool,
-           require_newline_after_table: bool) -> Header<'a> {
+    fn new(tokens: Tokenizer<'a>, array: bool, require_newline_after_table: bool) -> Header<'a> {
         Header {
             first: true,
             array: array,
@@ -1846,13 +1949,13 @@ impl<'a> E<'a> {
 impl<'a> Value<'a> {
     fn same_type(&self, other: &Value<'a>) -> bool {
         match (&self.e, &other.e) {
-            (&E::String(..), &E::String(..)) |
-            (&E::Integer(..), &E::Integer(..)) |
-            (&E::Float(..), &E::Float(..)) |
-            (&E::Boolean(..), &E::Boolean(..)) |
-            (&E::Datetime(..), &E::Datetime(..)) |
-            (&E::Array(..), &E::Array(..)) |
-            (&E::InlineTable(..), &E::InlineTable(..)) => true,
+            (&E::String(..), &E::String(..))
+            | (&E::Integer(..), &E::Integer(..))
+            | (&E::Float(..), &E::Float(..))
+            | (&E::Boolean(..), &E::Boolean(..))
+            | (&E::Datetime(..), &E::Datetime(..))
+            | (&E::Array(..), &E::Array(..))
+            | (&E::InlineTable(..), &E::InlineTable(..)) => true,
             (&E::DottedTable(..), &E::DottedTable(..)) => true,
 
             _ => false,
diff --git a/src/macros.rs b/src/macros.rs
index b4c7b22..8b76591 100644
--- a/src/macros.rs
+++ b/src/macros.rs
@@ -1,6 +1,6 @@
 pub use serde::de::{Deserialize, IntoDeserializer};
 
-use value::{Value, Table, Array};
+use value::{Array, Table, Value};
 
 /// Construct a [`toml::Value`] from TOML syntax.
 ///
@@ -424,7 +424,10 @@ pub fn push_toml(root: &mut Value, path: &[&str]) {
     if !target.is_array() {
         *target = Value::Array(Array::new());
     }
-    target.as_array_mut().unwrap().push(Value::Table(Table::new()));
+    target
+        .as_array_mut()
+        .unwrap()
+        .push(Value::Table(Table::new()));
 }
 
 fn traverse<'a>(root: &'a mut Value, path: &[&str]) -> &'a mut Value {
diff --git a/src/ser.rs b/src/ser.rs
index e1fe1a2..60e5b50 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -32,8 +32,8 @@ use std::fmt::{self, Write};
 use std::marker;
 use std::rc::Rc;
 
-use serde::ser;
 use datetime;
+use serde::ser;
 
 /// Serialize the given data structure as a TOML byte vector.
 ///
@@ -41,7 +41,8 @@ use datetime;
 /// fail, if `T` contains a map with non-string keys, or if `T` attempts to
 /// serialize an unsupported datatype such as an enum, tuple, or tuple struct.
 pub fn to_vec<T: ?Sized>(value: &T) -> Result<Vec<u8>, Error>
-    where T: ser::Serialize,
+where
+    T: ser::Serialize,
 {
     to_string(value).map(|e| e.into_bytes())
 }
@@ -87,7 +88,8 @@ pub fn to_vec<T: ?Sized>(value: &T) -> Result<Vec<u8>, Error>
 /// }
 /// ```
 pub fn to_string<T: ?Sized>(value: &T) -> Result<String, Error>
-    where T: ser::Serialize,
+where
+    T: ser::Serialize,
 {
     let mut dst = String::with_capacity(128);
     value.serialize(&mut Serializer::new(&mut dst))?;
@@ -99,7 +101,8 @@ pub fn to_string<T: ?Sized>(value: &T) -> Result<String, Error>
 /// This is identical to `to_string` except the output string has a more
 /// "pretty" output. See `Serializer::pretty` for more details.
 pub fn to_string_pretty<T: ?Sized>(value: &T) -> Result<String, Error>
-    where T: ser::Serialize,
+where
+    T: ser::Serialize,
 {
     let mut dst = String::with_capacity(128);
     value.serialize(&mut Serializer::pretty(&mut dst))?;
@@ -177,9 +180,7 @@ struct StringSettings {
 
 impl StringSettings {
     fn pretty() -> StringSettings {
-        StringSettings {
-            literal: true,
-        }
+        StringSettings { literal: true }
     }
 }
 
@@ -239,7 +240,7 @@ pub enum SerializeTable<'a: 'b, 'b> {
         key: String,
         first: Cell<bool>,
         table_emitted: Cell<bool>,
-    }
+    },
 }
 
 impl<'a> Serializer<'a> {
@@ -333,13 +334,13 @@ impl<'a> Serializer<'a> {
     /// """
     /// ```
     pub fn pretty_string_literal(&mut self, value: bool) -> &mut Self {
-        let use_default = if let &mut Some(ref mut s) = &mut Rc::get_mut(&mut self.settings)
-                .unwrap().string {
-            s.literal = value;
-            false
-        } else {
-            true
-        };
+        let use_default =
+            if let &mut Some(ref mut s) = &mut Rc::get_mut(&mut self.settings).unwrap().string {
+                s.literal = value;
+                false
+            } else {
+                true
+            };
 
         if use_default {
             let mut string = StringSettings::pretty();
@@ -389,13 +390,13 @@ impl<'a> Serializer<'a> {
     ///
     /// See `Serializer::pretty_array` for more details.
     pub fn pretty_array_indent(&mut self, value: usize) -> &mut Self {
-        let use_default = if let &mut Some(ref mut a) = &mut Rc::get_mut(&mut self.settings)
-                .unwrap().array {
-            a.indent = value;
-            false
-        } else {
-            true
-        };
+        let use_default =
+            if let &mut Some(ref mut a) = &mut Rc::get_mut(&mut self.settings).unwrap().array {
+                a.indent = value;
+                false
+            } else {
+                true
+            };
 
         if use_default {
             let mut array = ArraySettings::pretty();
@@ -409,13 +410,13 @@ impl<'a> Serializer<'a> {
     ///
     /// See `Serializer::pretty_array` for more details.
     pub fn pretty_array_trailing_comma(&mut self, value: bool) -> &mut Self {
-        let use_default = if let &mut Some(ref mut a) = &mut Rc::get_mut(&mut self.settings)
-                .unwrap().array {
-            a.trailing_comma = value;
-            false
-        } else {
-            true
-        };
+        let use_default =
+            if let &mut Some(ref mut a) = &mut Rc::get_mut(&mut self.settings).unwrap().array {
+                a.trailing_comma = value;
+                false
+            } else {
+                true
+            };
 
         if use_default {
             let mut array = ArraySettings::pretty();
@@ -425,9 +426,7 @@ impl<'a> Serializer<'a> {
         self
     }
 
-    fn display<T: fmt::Display>(&mut self,
-                                t: T,
-                                type_: &'static str) -> Result<(), Error> {
+    fn display<T: fmt::Display>(&mut self, t: T, type_: &'static str) -> Result<(), Error> {
         self.emit_key(type_)?;
         drop(write!(self.dst, "{}", t));
         if let State::Table { .. } = self.state {
@@ -446,16 +445,26 @@ impl<'a> Serializer<'a> {
     fn _emit_key(&mut self, state: &State) -> Result<(), Error> {
         match *state {
             State::End => Ok(()),
-            State::Array { parent, first, type_, len } => {
+            State::Array {
+                parent,
+                first,
+                type_,
+                len,
+            } => {
                 assert!(type_.get().is_some());
                 if first.get() {
                     self._emit_key(parent)?;
                 }
                 self.emit_array(first, len)
             }
-            State::Table { parent, first, table_emitted, key } => {
+            State::Table {
+                parent,
+                first,
+                table_emitted,
+                key,
+            } => {
                 if table_emitted.get() {
-                    return Err(Error::ValueAfterTable)
+                    return Err(Error::ValueAfterTable);
                 }
                 if first.get() {
                     self.emit_table_header(parent)?;
@@ -476,7 +485,7 @@ impl<'a> Serializer<'a> {
                 } else {
                     self.dst.push_str(", ")
                 }
-            },
+            }
             (_, &Some(ref a)) => {
                 if first.get() {
                     self.dst.push_str("[\n")
@@ -486,7 +495,7 @@ impl<'a> Serializer<'a> {
                 for _ in 0..a.indent {
                     self.dst.push_str(" ");
                 }
-            },
+            }
         }
         Ok(())
     }
@@ -498,7 +507,7 @@ impl<'a> Serializer<'a> {
         };
         if let Some(prev) = prev.get() {
             if prev != type_ {
-                return Err(Error::ArrayMixedType)
+                return Err(Error::ArrayMixedType);
             }
         } else {
             prev.set(Some(type_));
@@ -507,14 +516,9 @@ impl<'a> Serializer<'a> {
     }
 
     fn escape_key(&mut self, key: &str) -> Result<(), Error> {
-        let ok = key.chars().all(|c| {
-            match c {
-                'a' ... 'z' |
-                'A' ... 'Z' |
-                '0' ... '9' |
-                '-' | '_' => true,
-                _ => false,
-            }
+        let ok = key.chars().all(|c| match c {
+            'a'...'z' | 'A'...'Z' | '0'...'9' | '-' | '_' => true,
+            _ => false,
         });
         if ok {
             drop(write!(self.dst, "{}", key));
@@ -570,7 +574,7 @@ impl<'a> Serializer<'a> {
                         found_singles = 0
                     }
                     match ch {
-                        '\t' => {},
+                        '\t' => {}
                         '\n' => ty = Type::NewlineTripple,
                         // note that the following are invalid: \b \f \r
                         c if c < '\u{1f}' => can_be_pretty = false, // Invalid control character
@@ -606,8 +610,9 @@ impl<'a> Serializer<'a> {
 
         let repr = if !is_key && self.settings.string.is_some() {
             match (&self.settings.string, do_pretty(value)) {
-                (&Some(StringSettings { literal: false, .. }), Repr::Literal(_, ty)) =>
-                    Repr::Std(ty),
+                (&Some(StringSettings { literal: false, .. }), Repr::Literal(_, ty)) => {
+                    Repr::Std(ty)
+                }
                 (_, r @ _) => r,
             }
         } else {
@@ -626,26 +631,23 @@ impl<'a> Serializer<'a> {
                     Type::OnelineSingle => self.dst.push('\''),
                     _ => self.dst.push_str("'''"),
                 }
-            },
+            }
             Repr::Std(ty) => {
                 match ty {
-                    Type::NewlineTripple =>  self.dst.push_str("\"\"\"\n"),
+                    Type::NewlineTripple => self.dst.push_str("\"\"\"\n"),
                     // note: OnelineTripple can happen if do_pretty wants to do
                     // '''it's one line'''
                     // but settings.string.literal == false
-                    Type::OnelineSingle |
-                        Type::OnelineTripple =>  self.dst.push('"'),
+                    Type::OnelineSingle | Type::OnelineTripple => self.dst.push('"'),
                 }
                 for ch in value.chars() {
                     match ch {
                         '\u{8}' => self.dst.push_str("\\b"),
                         '\u{9}' => self.dst.push_str("\\t"),
-                        '\u{a}' => {
-                            match ty {
-                                Type::NewlineTripple =>  self.dst.push('\n'),
-                                Type::OnelineSingle =>  self.dst.push_str("\\n"),
-                                _ => unreachable!(),
-                            }
+                        '\u{a}' => match ty {
+                            Type::NewlineTripple => self.dst.push('\n'),
+                            Type::OnelineSingle => self.dst.push_str("\\n"),
+                            _ => unreachable!(),
                         },
                         '\u{c}' => self.dst.push_str("\\f"),
                         '\u{d}' => self.dst.push_str("\\r"),
@@ -656,10 +658,10 @@ impl<'a> Serializer<'a> {
                     }
                 }
                 match ty {
-                    Type::NewlineTripple =>  self.dst.push_str("\"\"\""),
+                    Type::NewlineTripple => self.dst.push_str("\"\"\""),
                     Type::OnelineSingle | Type::OnelineTripple => self.dst.push('"'),
                 }
-            },
+            }
         }
         Ok(())
     }
@@ -684,7 +686,11 @@ impl<'a> Serializer<'a> {
             if !first.get() {
                 break;
             }
-            if let State::Array { parent: &State::Table {..}, ..} = *parent {
+            if let State::Array {
+                parent: &State::Table { .. },
+                ..
+            } = *parent
+            {
                 self.emit_table_header(parent)?;
                 break;
             }
@@ -697,7 +703,7 @@ impl<'a> Serializer<'a> {
                     // table in the document.
                     self.dst.push('\n');
                 }
-            },
+            }
             State::Array { parent, first, .. } => {
                 if !first.get() {
                     // Always newline if we are not the first item in the
@@ -709,7 +715,7 @@ impl<'a> Serializer<'a> {
                         self.dst.push('\n');
                     }
                 }
-            },
+            }
             _ => {}
         }
         self.dst.push_str("[");
@@ -728,9 +734,14 @@ impl<'a> Serializer<'a> {
         match *key {
             State::Array { parent, .. } => self.emit_key_part(parent),
             State::End => Ok(true),
-            State::Table { key, parent, table_emitted, .. } => {
+            State::Table {
+                key,
+                parent,
+                table_emitted,
+                ..
+            } => {
                 table_emitted.set(true);
-                let first  = self.emit_key_part(parent)?;
+                let first = self.emit_key_part(parent)?;
                 if !first {
                     self.dst.push_str(".");
                 }
@@ -841,7 +852,8 @@ impl<'a, 'b> ser::Serializer for &'b mut Serializer<'a> {
     }
 
     fn serialize_some<T: ?Sized>(self, value: &T) -> Result<(), Self::Error>
-        where T: ser::Serialize
+    where
+        T: ser::Serialize,
     {
         value.serialize(self)
     }
@@ -850,40 +862,44 @@ impl<'a, 'b> ser::Serializer for &'b mut Serializer<'a> {
         Err(Error::UnsupportedType)
     }
 
-    fn serialize_unit_struct(self,
-                             _name: &'static str)
-                             -> Result<(), Self::Error> {
+    fn serialize_unit_struct(self, _name: &'static str) -> Result<(), Self::Error> {
         Err(Error::UnsupportedType)
     }
 
-    fn serialize_unit_variant(self,
-                              _name: &'static str,
-                              _variant_index: u32,
-                              variant: &'static str)
-                              -> Result<(), Self::Error> {
+    fn serialize_unit_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+    ) -> Result<(), Self::Error> {
         self.serialize_str(variant)
     }
 
-    fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T)
-                                           -> Result<(), Self::Error>
-        where T: ser::Serialize,
+    fn serialize_newtype_struct<T: ?Sized>(
+        self,
+        _name: &'static str,
+        value: &T,
+    ) -> Result<(), Self::Error>
+    where
+        T: ser::Serialize,
     {
         value.serialize(self)
     }
 
-    fn serialize_newtype_variant<T: ?Sized>(self,
-                                            _name: &'static str,
-                                            _variant_index: u32,
-                                            _variant: &'static str,
-                                            _value: &T)
-                                            -> Result<(), Self::Error>
-        where T: ser::Serialize,
+    fn serialize_newtype_variant<T: ?Sized>(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _value: &T,
+    ) -> Result<(), Self::Error>
+    where
+        T: ser::Serialize,
     {
         Err(Error::UnsupportedType)
     }
 
-    fn serialize_seq(self, len: Option<usize>)
-                     -> Result<Self::SerializeSeq, Self::Error> {
+    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
         self.array_type("array")?;
         Ok(SerializeSeq {
             ser: self,
@@ -893,27 +909,29 @@ impl<'a, 'b> ser::Serializer for &'b mut Serializer<'a> {
         })
     }
 
-    fn serialize_tuple(self, len: usize)
-                       -> Result<Self::SerializeTuple, Self::Error> {
+    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
         self.serialize_seq(Some(len))
     }
 
-    fn serialize_tuple_struct(self, _name: &'static str, len: usize)
-                              -> Result<Self::SerializeTupleStruct, Self::Error> {
+    fn serialize_tuple_struct(
+        self,
+        _name: &'static str,
+        len: usize,
+    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
         self.serialize_seq(Some(len))
     }
 
-    fn serialize_tuple_variant(self,
-                               _name: &'static str,
-                               _variant_index: u32,
-                               _variant: &'static str,
-                               len: usize)
-                               -> Result<Self::SerializeTupleVariant, Self::Error> {
+    fn serialize_tuple_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        len: usize,
+    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
         self.serialize_seq(Some(len))
     }
 
-    fn serialize_map(self, _len: Option<usize>)
-                     -> Result<Self::SerializeMap, Self::Error> {
+    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
         self.array_type("table")?;
         Ok(SerializeTable::Table {
             ser: self,
@@ -923,8 +941,11 @@ impl<'a, 'b> ser::Serializer for &'b mut Serializer<'a> {
         })
     }
 
-    fn serialize_struct(self, name: &'static str, _len: usize)
-                        -> Result<Self::SerializeStruct, Self::Error> {
+    fn serialize_struct(
+        self,
+        name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStruct, Self::Error> {
         if name == datetime::NAME {
             self.array_type("datetime")?;
             Ok(SerializeTable::Datetime(self))
@@ -939,12 +960,13 @@ impl<'a, 'b> ser::Serializer for &'b mut Serializer<'a> {
         }
     }
 
-    fn serialize_struct_variant(self,
-                                _name: &'static str,
-                                _variant_index: u32,
-                                _variant: &'static str,
-                                _len: usize)
-                                -> Result<Self::SerializeStructVariant, Self::Error> {
+    fn serialize_struct_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStructVariant, Self::Error> {
         Err(Error::UnsupportedType)
     }
 }
@@ -954,7 +976,8 @@ impl<'a, 'b> ser::SerializeSeq for SerializeSeq<'a, 'b> {
     type Error = Error;
 
     fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
-        where T: ser::Serialize,
+    where
+        T: ser::Serialize,
     {
         value.serialize(&mut Serializer {
             dst: &mut *self.ser.dst,
@@ -973,19 +996,17 @@ impl<'a, 'b> ser::SerializeSeq for SerializeSeq<'a, 'b> {
     fn end(self) -> Result<(), Error> {
         match self.type_.get() {
             Some("table") => return Ok(()),
-            Some(_) => {
-                match (self.len, &self.ser.settings.array) {
-                    (Some(0...1), _) | (_, &None) => {
-                        self.ser.dst.push_str("]");
-                    },
-                    (_, &Some(ref a)) => {
-                        if a.trailing_comma {
-                            self.ser.dst.push_str(",");
-                        }
-                        self.ser.dst.push_str("\n]");
-                    },
+            Some(_) => match (self.len, &self.ser.settings.array) {
+                (Some(0...1), _) | (_, &None) => {
+                    self.ser.dst.push_str("]");
                 }
-            }
+                (_, &Some(ref a)) => {
+                    if a.trailing_comma {
+                        self.ser.dst.push_str(",");
+                    }
+                    self.ser.dst.push_str("\n]");
+                }
+            },
             None => {
                 assert!(self.first.get());
                 self.ser.emit_key("array")?;
@@ -1004,7 +1025,8 @@ impl<'a, 'b> ser::SerializeTuple for SerializeSeq<'a, 'b> {
     type Error = Error;
 
     fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
-        where T: ser::Serialize,
+    where
+        T: ser::Serialize,
     {
         ser::SerializeSeq::serialize_element(self, value)
     }
@@ -1019,7 +1041,8 @@ impl<'a, 'b> ser::SerializeTupleVariant for SerializeSeq<'a, 'b> {
     type Error = Error;
 
     fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
-        where T: ser::Serialize,
+    where
+        T: ser::Serialize,
     {
         ser::SerializeSeq::serialize_element(self, value)
     }
@@ -1034,7 +1057,8 @@ impl<'a, 'b> ser::SerializeTupleStruct for SerializeSeq<'a, 'b> {
     type Error = Error;
 
     fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
-        where T: ser::Serialize,
+    where
+        T: ser::Serialize,
     {
         ser::SerializeSeq::serialize_element(self, value)
     }
@@ -1049,7 +1073,8 @@ impl<'a, 'b> ser::SerializeMap for SerializeTable<'a, 'b> {
     type Error = Error;
 
     fn serialize_key<T: ?Sized>(&mut self, input: &T) -> Result<(), Error>
-        where T: ser::Serialize,
+    where
+        T: ser::Serialize,
     {
         match *self {
             SerializeTable::Datetime(_) => panic!(), // shouldn't be possible
@@ -1062,7 +1087,8 @@ impl<'a, 'b> ser::SerializeMap for SerializeTable<'a, 'b> {
     }
 
     fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
-        where T: ser::Serialize,
+    where
+        T: ser::Serialize,
     {
         match *self {
             SerializeTable::Datetime(_) => panic!(), // shouldn't be possible
@@ -1085,7 +1111,7 @@ impl<'a, 'b> ser::SerializeMap for SerializeTable<'a, 'b> {
                 });
                 match res {
                     Ok(()) => first.set(false),
-                    Err(Error::UnsupportedNone) => {},
+                    Err(Error::UnsupportedNone) => {}
                     Err(e) => return Err(e),
                 }
             }
@@ -1096,7 +1122,7 @@ impl<'a, 'b> ser::SerializeMap for SerializeTable<'a, 'b> {
     fn end(self) -> Result<(), Error> {
         match self {
             SerializeTable::Datetime(_) => panic!(), // shouldn't be possible
-            SerializeTable::Table { ser, first, ..  } => {
+            SerializeTable::Table { ser, first, .. } => {
                 if first.get() {
                     let state = ser.state.clone();
                     ser.emit_table_header(&state)?;
@@ -1111,16 +1137,16 @@ impl<'a, 'b> ser::SerializeStruct for SerializeTable<'a, 'b> {
     type Ok = ();
     type Error = Error;
 
-    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T)
-                                  -> Result<(), Error>
-        where T: ser::Serialize,
+    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
+    where
+        T: ser::Serialize,
     {
         match *self {
             SerializeTable::Datetime(ref mut ser) => {
                 if key == datetime::FIELD {
                     value.serialize(DateStrEmitter(&mut *ser))?;
                 } else {
-                    return Err(Error::DateInvalid)
+                    return Err(Error::DateInvalid);
                 }
             }
             SerializeTable::Table {
@@ -1141,7 +1167,7 @@ impl<'a, 'b> ser::SerializeStruct for SerializeTable<'a, 'b> {
                 });
                 match res {
                     Ok(()) => first.set(false),
-                    Err(Error::UnsupportedNone) => {},
+                    Err(Error::UnsupportedNone) => {}
                     Err(e) => return Err(e),
                 }
             }
@@ -1151,8 +1177,8 @@ impl<'a, 'b> ser::SerializeStruct for SerializeTable<'a, 'b> {
 
     fn end(self) -> Result<(), Error> {
         match self {
-            SerializeTable::Datetime(_) => {},
-            SerializeTable::Table { ser, first, ..  } => {
+            SerializeTable::Datetime(_) => {}
+            SerializeTable::Table { ser, first, .. } => {
                 if first.get() {
                     let state = ser.state.clone();
                     ser.emit_table_header(&state)?;
@@ -1238,7 +1264,8 @@ impl<'a, 'b> ser::Serializer for DateStrEmitter<'a, 'b> {
     }
 
     fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<(), Self::Error>
-        where T: ser::Serialize
+    where
+        T: ser::Serialize,
     {
         Err(Error::KeyNotString)
     }
@@ -1247,78 +1274,88 @@ impl<'a, 'b> ser::Serializer for DateStrEmitter<'a, 'b> {
         Err(Error::KeyNotString)
     }
 
-    fn serialize_unit_struct(self,
-                             _name: &'static str)
-                             -> Result<(), Self::Error> {
+    fn serialize_unit_struct(self, _name: &'static str) -> Result<(), Self::Error> {
         Err(Error::DateInvalid)
     }
 
-    fn serialize_unit_variant(self,
-                              _name: &'static str,
-                              _variant_index: u32,
-                              _variant: &'static str)
-                              -> Result<(), Self::Error> {
+    fn serialize_unit_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+    ) -> Result<(), Self::Error> {
         Err(Error::DateInvalid)
     }
 
-    fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, _value: &T)
-                                           -> Result<(), Self::Error>
-        where T: ser::Serialize,
+    fn serialize_newtype_struct<T: ?Sized>(
+        self,
+        _name: &'static str,
+        _value: &T,
+    ) -> Result<(), Self::Error>
+    where
+        T: ser::Serialize,
     {
         Err(Error::DateInvalid)
     }
 
-    fn serialize_newtype_variant<T: ?Sized>(self,
-                                            _name: &'static str,
-                                            _variant_index: u32,
-                                            _variant: &'static str,
-                                            _value: &T)
-                                            -> Result<(), Self::Error>
-        where T: ser::Serialize,
+    fn serialize_newtype_variant<T: ?Sized>(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _value: &T,
+    ) -> Result<(), Self::Error>
+    where
+        T: ser::Serialize,
     {
         Err(Error::DateInvalid)
     }
 
-    fn serialize_seq(self, _len: Option<usize>)
-                     -> Result<Self::SerializeSeq, Self::Error> {
+    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
         Err(Error::DateInvalid)
     }
 
-    fn serialize_tuple(self, _len: usize)
-                       -> Result<Self::SerializeTuple, Self::Error> {
+    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
         Err(Error::DateInvalid)
     }
 
-    fn serialize_tuple_struct(self, _name: &'static str, _len: usize)
-                              -> Result<Self::SerializeTupleStruct, Self::Error> {
+    fn serialize_tuple_struct(
+        self,
+        _name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
         Err(Error::DateInvalid)
     }
 
-    fn serialize_tuple_variant(self,
-                               _name: &'static str,
-                               _variant_index: u32,
-                               _variant: &'static str,
-                               _len: usize)
-                               -> Result<Self::SerializeTupleVariant, Self::Error> {
+    fn serialize_tuple_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
         Err(Error::DateInvalid)
     }
 
-    fn serialize_map(self, _len: Option<usize>)
-                     -> Result<Self::SerializeMap, Self::Error> {
+    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
         Err(Error::DateInvalid)
     }
 
-    fn serialize_struct(self, _name: &'static str, _len: usize)
-                        -> Result<Self::SerializeStruct, Self::Error> {
+    fn serialize_struct(
+        self,
+        _name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStruct, Self::Error> {
         Err(Error::DateInvalid)
     }
 
-    fn serialize_struct_variant(self,
-                                _name: &'static str,
-                                _variant_index: u32,
-                                _variant: &'static str,
-                                _len: usize)
-                                -> Result<Self::SerializeStructVariant, Self::Error> {
+    fn serialize_struct_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStructVariant, Self::Error> {
         Err(Error::DateInvalid)
     }
 }
@@ -1397,7 +1434,8 @@ impl ser::Serializer for StringExtractor {
     }
 
     fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<String, Self::Error>
-        where T: ser::Serialize
+    where
+        T: ser::Serialize,
     {
         Err(Error::KeyNotString)
     }
@@ -1406,78 +1444,88 @@ impl ser::Serializer for StringExtractor {
         Err(Error::KeyNotString)
     }
 
-    fn serialize_unit_struct(self,
-                             _name: &'static str)
-                             -> Result<String, Self::Error> {
+    fn serialize_unit_struct(self, _name: &'static str) -> Result<String, Self::Error> {
         Err(Error::KeyNotString)
     }
 
-    fn serialize_unit_variant(self,
-                              _name: &'static str,
-                              _variant_index: u32,
-                              _variant: &'static str)
-                              -> Result<String, Self::Error> {
+    fn serialize_unit_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+    ) -> Result<String, Self::Error> {
         Err(Error::KeyNotString)
     }
 
-    fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T)
-                                           -> Result<String, Self::Error>
-        where T: ser::Serialize,
+    fn serialize_newtype_struct<T: ?Sized>(
+        self,
+        _name: &'static str,
+        value: &T,
+    ) -> Result<String, Self::Error>
+    where
+        T: ser::Serialize,
     {
         value.serialize(self)
     }
 
-    fn serialize_newtype_variant<T: ?Sized>(self,
-                                            _name: &'static str,
-                                            _variant_index: u32,
-                                            _variant: &'static str,
-                                            _value: &T)
-                                            -> Result<String, Self::Error>
-        where T: ser::Serialize,
+    fn serialize_newtype_variant<T: ?Sized>(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _value: &T,
+    ) -> Result<String, Self::Error>
+    where
+        T: ser::Serialize,
     {
         Err(Error::KeyNotString)
     }
 
-    fn serialize_seq(self, _len: Option<usize>)
-                     -> Result<Self::SerializeSeq, Self::Error> {
+    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
         Err(Error::KeyNotString)
     }
 
-    fn serialize_tuple(self, _len: usize)
-                       -> Result<Self::SerializeTuple, Self::Error> {
+    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
         Err(Error::KeyNotString)
     }
 
-    fn serialize_tuple_struct(self, _name: &'static str, _len: usize)
-                              -> Result<Self::SerializeTupleStruct, Self::Error> {
+    fn serialize_tuple_struct(
+        self,
+        _name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
         Err(Error::KeyNotString)
     }
 
-    fn serialize_tuple_variant(self,
-                               _name: &'static str,
-                               _variant_index: u32,
-                               _variant: &'static str,
-                               _len: usize)
-                               -> Result<Self::SerializeTupleVariant, Self::Error> {
+    fn serialize_tuple_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
         Err(Error::KeyNotString)
     }
 
-    fn serialize_map(self, _len: Option<usize>)
-                     -> Result<Self::SerializeMap, Self::Error> {
+    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
         Err(Error::KeyNotString)
     }
 
-    fn serialize_struct(self, _name: &'static str, _len: usize)
-                        -> Result<Self::SerializeStruct, Self::Error> {
+    fn serialize_struct(
+        self,
+        _name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStruct, Self::Error> {
         Err(Error::KeyNotString)
     }
 
-    fn serialize_struct_variant(self,
-                                _name: &'static str,
-                                _variant_index: u32,
-                                _variant: &'static str,
-                                _len: usize)
-                                -> Result<Self::SerializeStructVariant, Self::Error> {
+    fn serialize_struct_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStructVariant, Self::Error> {
         Err(Error::KeyNotString)
     }
 }
@@ -1549,12 +1597,12 @@ enum Category {
 /// # type Dependency = String;
 /// # fn main() {}
 /// ```
-pub fn tables_last<'a, I, K, V, S>(data: &'a I, serializer: S)
-                                   -> Result<S::Ok, S::Error>
-    where &'a I: IntoIterator<Item = (K, V)>,
-          K: ser::Serialize,
-          V: ser::Serialize,
-          S: ser::Serializer
+pub fn tables_last<'a, I, K, V, S>(data: &'a I, serializer: S) -> Result<S::Ok, S::Error>
+where
+    &'a I: IntoIterator<Item = (K, V)>,
+    K: ser::Serialize,
+    V: ser::Serialize,
+    S: ser::Serializer,
 {
     use serde::ser::SerializeMap;
 
@@ -1668,15 +1716,30 @@ impl<E: ser::Error> ser::Serializer for Categorize<E> {
         Err(ser::Error::custom("unsupported"))
     }
 
-    fn serialize_unit_variant(self, _: &'static str, _: u32, _: &'static str) -> Result<Self::Ok, Self::Error> {
+    fn serialize_unit_variant(
+        self,
+        _: &'static str,
+        _: u32,
+        _: &'static str,
+    ) -> Result<Self::Ok, Self::Error> {
         Err(ser::Error::custom("unsupported"))
     }
 
-    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(self, _: &'static str, v: &T) -> Result<Self::Ok, Self::Error> {
+    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
+        self,
+        _: &'static str,
+        v: &T,
+    ) -> Result<Self::Ok, Self::Error> {
         v.serialize(self)
     }
 
-    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(self, _: &'static str, _: u32, _: &'static str, _: &T) -> Result<Self::Ok, Self::Error> {
+    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
+        self,
+        _: &'static str,
+        _: u32,
+        _: &'static str,
+        _: &T,
+    ) -> Result<Self::Ok, Self::Error> {
         Err(ser::Error::custom("unsupported"))
     }
 
@@ -1688,11 +1751,21 @@ impl<E: ser::Error> ser::Serializer for Categorize<E> {
         Ok(self)
     }
 
-    fn serialize_tuple_struct(self, _: &'static str, _: usize) -> Result<Self::SerializeTupleStruct, Self::Error> {
+    fn serialize_tuple_struct(
+        self,
+        _: &'static str,
+        _: usize,
+    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
         Ok(self)
     }
 
-    fn serialize_tuple_variant(self, _: &'static str, _: u32, _: &'static str, _: usize) -> Result<Self::SerializeTupleVariant, Self::Error> {
+    fn serialize_tuple_variant(
+        self,
+        _: &'static str,
+        _: u32,
+        _: &'static str,
+        _: usize,
+    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
         Ok(self)
     }
 
@@ -1704,7 +1777,13 @@ impl<E: ser::Error> ser::Serializer for Categorize<E> {
         Ok(self)
     }
 
-    fn serialize_struct_variant(self, _: &'static str, _: u32, _: &'static str, _: usize) -> Result<Self::SerializeStructVariant, Self::Error> {
+    fn serialize_struct_variant(
+        self,
+        _: &'static str,
+        _: u32,
+        _: &'static str,
+        _: usize,
+    ) -> Result<Self::SerializeStructVariant, Self::Error> {
         Err(ser::Error::custom("unsupported"))
     }
 }
@@ -1713,8 +1792,7 @@ impl<E: ser::Error> ser::SerializeSeq for Categorize<E> {
     type Ok = Category;
     type Error = E;
 
-    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, _: &T)
-                                                     -> Result<(), Self::Error> {
+    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, _: &T) -> Result<(), Self::Error> {
         Ok(())
     }
 
@@ -1727,8 +1805,7 @@ impl<E: ser::Error> ser::SerializeTuple for Categorize<E> {
     type Ok = Category;
     type Error = E;
 
-    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, _: &T)
-                                                     -> Result<(), Self::Error> {
+    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, _: &T) -> Result<(), Self::Error> {
         Ok(())
     }
 
@@ -1741,8 +1818,7 @@ impl<E: ser::Error> ser::SerializeTupleVariant for Categorize<E> {
     type Ok = Category;
     type Error = E;
 
-    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self, _: &T)
-                                                   -> Result<(), Self::Error> {
+    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self, _: &T) -> Result<(), Self::Error> {
         Ok(())
     }
 
@@ -1755,8 +1831,7 @@ impl<E: ser::Error> ser::SerializeTupleStruct for Categorize<E> {
     type Ok = Category;
     type Error = E;
 
-    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self, _: &T)
-                                                   -> Result<(), Self::Error> {
+    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self, _: &T) -> Result<(), Self::Error> {
         Ok(())
     }
 
@@ -1769,13 +1844,11 @@ impl<E: ser::Error> ser::SerializeMap for Categorize<E> {
     type Ok = Category;
     type Error = E;
 
-    fn serialize_key<T: ?Sized + ser::Serialize>(&mut self, _: &T)
-                                                 -> Result<(), Self::Error> {
+    fn serialize_key<T: ?Sized + ser::Serialize>(&mut self, _: &T) -> Result<(), Self::Error> {
         Ok(())
     }
 
-    fn serialize_value<T: ?Sized + ser::Serialize>(&mut self, _: &T)
-                                                   -> Result<(), Self::Error> {
+    fn serialize_value<T: ?Sized + ser::Serialize>(&mut self, _: &T) -> Result<(), Self::Error> {
         Ok(())
     }
 
@@ -1788,10 +1861,9 @@ impl<E: ser::Error> ser::SerializeStruct for Categorize<E> {
     type Ok = Category;
     type Error = E;
 
-    fn serialize_field<T: ?Sized>(&mut self,
-                                  _: &'static str,
-                                  _: &T) -> Result<(), Self::Error>
-        where T: ser::Serialize,
+    fn serialize_field<T: ?Sized>(&mut self, _: &'static str, _: &T) -> Result<(), Self::Error>
+    where
+        T: ser::Serialize,
     {
         Ok(())
     }
diff --git a/src/spanned.rs b/src/spanned.rs
index abbbd49..fb476ee 100644
--- a/src/spanned.rs
+++ b/src/spanned.rs
@@ -78,15 +78,18 @@ impl<T> Spanned<T> {
 }
 
 impl<'de, T> de::Deserialize<'de> for Spanned<T>
-    where T: de::Deserialize<'de>
+where
+    T: de::Deserialize<'de>,
 {
     fn deserialize<D>(deserializer: D) -> Result<Spanned<T>, D::Error>
-        where D: de::Deserializer<'de>
+    where
+        D: de::Deserializer<'de>,
     {
         struct SpannedVisitor<T>(::std::marker::PhantomData<T>);
 
         impl<'de, T> de::Visitor<'de> for SpannedVisitor<T>
-            where T: de::Deserialize<'de>
+        where
+            T: de::Deserialize<'de>,
         {
             type Value = Spanned<T>;
 
@@ -95,22 +98,23 @@ impl<'de, T> de::Deserialize<'de> for Spanned<T>
             }
 
             fn visit_map<V>(self, mut visitor: V) -> Result<Spanned<T>, V::Error>
-                where V: de::MapAccess<'de>
+            where
+                V: de::MapAccess<'de>,
             {
                 if visitor.next_key()? != Some(START) {
-                    return Err(de::Error::custom("spanned start key not found"))
+                    return Err(de::Error::custom("spanned start key not found"));
                 }
 
                 let start: usize = visitor.next_value()?;
 
                 if visitor.next_key()? != Some(END) {
-                    return Err(de::Error::custom("spanned end key not found"))
+                    return Err(de::Error::custom("spanned end key not found"));
                 }
 
                 let end: usize = visitor.next_value()?;
 
                 if visitor.next_key()? != Some(VALUE) {
-                    return Err(de::Error::custom("spanned value key not found"))
+                    return Err(de::Error::custom("spanned value key not found"));
                 }
 
                 let value: T = visitor.next_value()?;
@@ -118,7 +122,7 @@ impl<'de, T> de::Deserialize<'de> for Spanned<T>
                 Ok(Spanned {
                     start: start,
                     end: end,
-                    value: value
+                    value: value,
                 })
             }
         }
diff --git a/src/tokens.rs b/src/tokens.rs
index 382c1ec..064c804 100644
--- a/src/tokens.rs
+++ b/src/tokens.rs
@@ -38,7 +38,11 @@ pub enum Token<'a> {
     RightBracket,
 
     Keylike(&'a str),
-    String { src: &'a str, val: Cow<'a, str>, multiline: bool },
+    String {
+        src: &'a str,
+        val: Cow<'a, str>,
+        multiline: bool,
+    },
 }
 
 #[derive(Eq, PartialEq, Debug)]
@@ -53,7 +57,11 @@ pub enum Error {
     NewlineInTableKey(usize),
     MultilineStringKey(usize),
     EmptyTableKey(usize),
-    Wanted { at: usize, expected: &'static str, found: &'static str },
+    Wanted {
+        at: usize,
+        expected: &'static str,
+        found: &'static str,
+    },
 }
 
 #[derive(Clone)]
@@ -101,10 +109,16 @@ impl<'a> Tokenizer<'a> {
             Some((start, '}')) => (start, RightBrace),
             Some((start, '[')) => (start, LeftBracket),
             Some((start, ']')) => (start, RightBracket),
-            Some((start, '\'')) => return self.literal_string(start)
-                .map(|t| Some((self.step_span(start), t))),
-            Some((start, '"')) => return self.basic_string(start)
-                .map(|t| Some((self.step_span(start), t))),
+            Some((start, '\'')) => {
+                return self
+                    .literal_string(start)
+                    .map(|t| Some((self.step_span(start), t)))
+            }
+            Some((start, '"')) => {
+                return self
+                    .basic_string(start)
+                    .map(|t| Some((self.step_span(start), t)))
+            }
             Some((start, ch)) if is_keylike(ch) => (start, self.keylike(start)),
 
             Some((start, ch)) => return Err(Error::Unexpected(start, ch)),
@@ -156,13 +170,11 @@ impl<'a> Tokenizer<'a> {
                     })
                 }
             }
-            None => {
-                Err(Error::Wanted {
-                    at: self.input.len(),
-                    expected: expected.describe(),
-                    found: "eof",
-                })
-            }
+            None => Err(Error::Wanted {
+                at: self.input.len(),
+                expected: expected.describe(),
+                found: "eof",
+            }),
         }
     }
 
@@ -170,33 +182,36 @@ impl<'a> Tokenizer<'a> {
         let current = self.current();
         match self.next()? {
             Some((span, Token::Keylike(k))) => Ok((span, k.into())),
-            Some((span, Token::String { src, val, multiline })) => {
+            Some((
+                span,
+                Token::String {
+                    src,
+                    val,
+                    multiline,
+                },
+            )) => {
                 let offset = self.substr_offset(src);
                 if multiline {
-                    return Err(Error::MultilineStringKey(offset))
+                    return Err(Error::MultilineStringKey(offset));
                 }
                 if val == "" {
-                    return Err(Error::EmptyTableKey(offset))
+                    return Err(Error::EmptyTableKey(offset));
                 }
                 match src.find('\n') {
                     None => Ok((span, val)),
                     Some(i) => Err(Error::NewlineInTableKey(offset + i)),
                 }
             }
-            Some((_, other)) => {
-                Err(Error::Wanted {
-                    at: current,
-                    expected: "a table key",
-                    found: other.describe(),
-                })
-            }
-            None => {
-                Err(Error::Wanted {
-                    at: self.input.len(),
-                    expected: "a table key",
-                    found: "eof",
-                })
-            }
+            Some((_, other)) => Err(Error::Wanted {
+                at: current,
+                expected: "a table key",
+                found: other.describe(),
+            }),
+            None => Err(Error::Wanted {
+                at: self.input.len(),
+                expected: "a table key",
+                found: "eof",
+            }),
         }
     }
 
@@ -209,7 +224,7 @@ impl<'a> Tokenizer<'a> {
 
     pub fn eat_comment(&mut self) -> Result<bool, Error> {
         if !self.eatc('#') {
-            return Ok(false)
+            return Ok(false);
         }
         drop(self.comment_token(0));
         self.eat_newline_or_eof().map(|()| true)
@@ -218,23 +233,19 @@ impl<'a> Tokenizer<'a> {
     pub fn eat_newline_or_eof(&mut self) -> Result<(), Error> {
         let current = self.current();
         match self.next()? {
-            None |
-            Some((_, Token::Newline)) => Ok(()),
-            Some((_, other)) => {
-                Err(Error::Wanted {
-                    at: current,
-                    expected: "newline",
-                    found: other.describe(),
-                })
-            }
+            None | Some((_, Token::Newline)) => Ok(()),
+            Some((_, other)) => Err(Error::Wanted {
+                at: current,
+                expected: "newline",
+                found: other.describe(),
+            }),
         }
     }
 
     pub fn skip_to_newline(&mut self) {
         loop {
             match self.one() {
-                Some((_, '\n')) |
-                None => break,
+                Some((_, '\n')) | None => break,
                 _ => {}
             }
         }
@@ -251,7 +262,11 @@ impl<'a> Tokenizer<'a> {
     }
 
     pub fn current(&mut self) -> usize {
-        self.chars.clone().next().map(|i| i.0).unwrap_or(self.input.len())
+        self.chars
+            .clone()
+            .next()
+            .map(|i| i.0)
+            .unwrap_or(self.input.len())
     }
 
     pub fn input(&self) -> &'a str {
@@ -268,30 +283,35 @@ impl<'a> Tokenizer<'a> {
     fn comment_token(&mut self, start: usize) -> Token<'a> {
         while let Some((_, ch)) = self.chars.clone().next() {
             if ch != '\t' && (ch < '\u{20}' || ch > '\u{10ffff}') {
-                break
+                break;
             }
             self.one();
         }
         Comment(&self.input[start..self.current()])
     }
 
-    fn read_string(&mut self,
-                   delim: char,
-                   start: usize,
-                   new_ch: &mut FnMut(&mut Tokenizer, &mut MaybeString,
-                                      bool, usize, char)
-                                     -> Result<(), Error>)
-                   -> Result<Token<'a>, Error> {
+    fn read_string(
+        &mut self,
+        delim: char,
+        start: usize,
+        new_ch: &mut FnMut(
+            &mut Tokenizer,
+            &mut MaybeString,
+            bool,
+            usize,
+            char,
+        ) -> Result<(), Error>,
+    ) -> Result<Token<'a>, Error> {
         let mut multiline = false;
         if self.eatc(delim) {
             if self.eatc(delim) {
                 multiline = true;
             } else {
                 return Ok(String {
-                    src: &self.input[start..start+2],
+                    src: &self.input[start..start + 2],
                     val: Cow::Borrowed(""),
                     multiline: false,
-                })
+                });
             }
         }
         let mut val = MaybeString::NotEscaped(self.current());
@@ -309,9 +329,9 @@ impl<'a> Tokenizer<'a> {
                         } else {
                             val.push('\n');
                         }
-                        continue
+                        continue;
                     } else {
-                        return Err(Error::NewlineInString(i))
+                        return Err(Error::NewlineInString(i));
                     }
                 }
                 Some((i, ch)) if ch == delim => {
@@ -319,7 +339,7 @@ impl<'a> Tokenizer<'a> {
                         for _ in 0..2 {
                             if !self.eatc(delim) {
                                 val.push(delim);
-                                continue 'outer
+                                continue 'outer;
                             }
                         }
                     }
@@ -327,10 +347,10 @@ impl<'a> Tokenizer<'a> {
                         src: &self.input[start..self.current()],
                         val: val.into_cow(&self.input[..i]),
                         multiline: multiline,
-                    })
+                    });
                 }
                 Some((i, c)) => new_ch(self, &mut val, multiline, i, c)?,
-                None => return Err(Error::UnterminatedString(start))
+                None => return Err(Error::UnterminatedString(start)),
             }
         }
     }
@@ -347,61 +367,56 @@ impl<'a> Tokenizer<'a> {
     }
 
     fn basic_string(&mut self, start: usize) -> Result<Token<'a>, Error> {
-        self.read_string('"', start, &mut |me, val, multi, i, ch| {
-            match ch {
-                '\\' => {
-                    val.to_owned(&me.input[..i]);
-                    match me.chars.next() {
-                        Some((_, '"')) => val.push('"'),
-                        Some((_, '\\')) => val.push('\\'),
-                        Some((_, 'b')) => val.push('\u{8}'),
-                        Some((_, 'f')) => val.push('\u{c}'),
-                        Some((_, 'n')) => val.push('\n'),
-                        Some((_, 'r')) => val.push('\r'),
-                        Some((_, 't')) => val.push('\t'),
-                        Some((i, c @ 'u')) |
-                        Some((i, c @ 'U')) => {
-                            let len = if c == 'u' {4} else {8};
-                            val.push(me.hex(start, i, len)?);
-                        }
-                        Some((i, c @ ' ')) |
-                        Some((i, c @ '\t')) |
-                        Some((i, c @ '\n')) if multi => {
-                            if c != '\n' {
-                                while let Some((_, ch)) = me.chars.clone().next() {
-                                    match ch {
-                                        ' ' | '\t' => {
-                                            me.chars.next();
-                                            continue
-                                        },
-                                        '\n' => {
-                                            me.chars.next();
-                                            break
-                                        },
-                                        _ => return Err(Error::InvalidEscape(i, c)),
-                                    }
-                                }
-                            }
+        self.read_string('"', start, &mut |me, val, multi, i, ch| match ch {
+            '\\' => {
+                val.to_owned(&me.input[..i]);
+                match me.chars.next() {
+                    Some((_, '"')) => val.push('"'),
+                    Some((_, '\\')) => val.push('\\'),
+                    Some((_, 'b')) => val.push('\u{8}'),
+                    Some((_, 'f')) => val.push('\u{c}'),
+                    Some((_, 'n')) => val.push('\n'),
+                    Some((_, 'r')) => val.push('\r'),
+                    Some((_, 't')) => val.push('\t'),
+                    Some((i, c @ 'u')) | Some((i, c @ 'U')) => {
+                        let len = if c == 'u' { 4 } else { 8 };
+                        val.push(me.hex(start, i, len)?);
+                    }
+                    Some((i, c @ ' ')) | Some((i, c @ '\t')) | Some((i, c @ '\n')) if multi => {
+                        if c != '\n' {
                             while let Some((_, ch)) = me.chars.clone().next() {
                                 match ch {
-                                    ' ' | '\t' | '\n' => {
+                                    ' ' | '\t' => {
+                                        me.chars.next();
+                                        continue;
+                                    }
+                                    '\n' => {
                                         me.chars.next();
+                                        break;
                                     }
-                                    _ => break,
+                                    _ => return Err(Error::InvalidEscape(i, c)),
                                 }
                             }
                         }
-                        Some((i, c)) => return Err(Error::InvalidEscape(i, c)),
-                        None => return Err(Error::UnterminatedString(start)),
+                        while let Some((_, ch)) = me.chars.clone().next() {
+                            match ch {
+                                ' ' | '\t' | '\n' => {
+                                    me.chars.next();
+                                }
+                                _ => break,
+                            }
+                        }
                     }
-                    Ok(())
-                }
-                ch if '\u{20}' <= ch && ch <= '\u{10ffff}' && ch != '\u{7f}' => {
-                    val.push(ch);
-                    Ok(())
+                    Some((i, c)) => return Err(Error::InvalidEscape(i, c)),
+                    None => return Err(Error::UnterminatedString(start)),
                 }
-                _ => Err(Error::InvalidCharInString(i, ch))
+                Ok(())
+            }
+            ch if '\u{20}' <= ch && ch <= '\u{10ffff}' && ch != '\u{7f}' => {
+                val.push(ch);
+                Ok(())
             }
+            _ => Err(Error::InvalidCharInString(i, ch)),
         })
     }
 
@@ -424,7 +439,7 @@ impl<'a> Tokenizer<'a> {
     fn keylike(&mut self, start: usize) -> Token<'a> {
         while let Some((_, ch)) = self.peek_one() {
             if !is_keylike(ch) {
-                break
+                break;
             }
             self.one();
         }
@@ -441,8 +456,14 @@ impl<'a> Tokenizer<'a> {
 
     /// Calculate the span of a single character.
     fn step_span(&mut self, start: usize) -> Span {
-        let end = self.peek_one().map(|t| t.0).unwrap_or_else(|| self.input.len());
-        Span { start: start, end: end }
+        let end = self
+            .peek_one()
+            .map(|t| t.0)
+            .unwrap_or_else(|| self.input.len());
+        Span {
+            start: start,
+            end: end,
+        }
     }
 
     /// Peek one char without consuming it.
@@ -465,7 +486,7 @@ impl<'a> Iterator for CrlfFold<'a> {
                 let mut attempt = self.chars.clone();
                 if let Some((_, '\n')) = attempt.next() {
                     self.chars = attempt;
-                    return (i, '\n')
+                    return (i, '\n');
                 }
             }
             (i, c)
@@ -499,11 +520,11 @@ impl MaybeString {
 }
 
 fn is_keylike(ch: char) -> bool {
-    ('A' <= ch && ch <= 'Z') ||
-        ('a' <= ch && ch <= 'z') ||
-        ('0' <= ch && ch <= '9') ||
-        ch == '-' ||
-        ch == '_'
+    ('A' <= ch && ch <= 'Z')
+        || ('a' <= ch && ch <= 'z')
+        || ('0' <= ch && ch <= '9')
+        || ch == '-'
+        || ch == '_'
 }
 
 impl<'a> Token<'a> {
@@ -520,7 +541,13 @@ impl<'a> Token<'a> {
             Token::LeftBrace => "a left brace",
             Token::RightBracket => "a right bracket",
             Token::LeftBracket => "a left bracket",
-            Token::String { multiline, .. } => if multiline { "a multiline string" } else { "a string" },
+            Token::String { multiline, .. } => {
+                if multiline {
+                    "a multiline string"
+                } else {
+                    "a string"
+                }
+            }
             Token::Colon => "a colon",
             Token::Plus => "a plus",
         }
@@ -529,8 +556,8 @@ impl<'a> Token<'a> {
 
 #[cfg(test)]
 mod tests {
+    use super::{Error, Token, Tokenizer};
     use std::borrow::Cow;
-    use super::{Tokenizer, Token, Error};
 
     fn err(input: &str, err: Error) {
         let mut t = Tokenizer::new(input);
@@ -544,11 +571,14 @@ mod tests {
         fn t(input: &str, val: &str, multiline: bool) {
             let mut t = Tokenizer::new(input);
             let (_, token) = t.next().unwrap().unwrap();
-            assert_eq!(token, Token::String {
-                src: input,
-                val: Cow::Borrowed(val),
-                multiline: multiline,
-            });
+            assert_eq!(
+                token,
+                Token::String {
+                    src: input,
+                    val: Cow::Borrowed(val),
+                    multiline: multiline,
+                }
+            );
             assert!(t.next().unwrap().is_none());
         }
 
@@ -567,11 +597,14 @@ mod tests {
         fn t(input: &str, val: &str, multiline: bool) {
             let mut t = Tokenizer::new(input);
             let (_, token) = t.next().unwrap().unwrap();
-            assert_eq!(token, Token::String {
-                src: input,
-                val: Cow::Borrowed(val),
-                multiline: multiline,
-            });
+            assert_eq!(
+                token,
+                Token::String {
+                    src: input,
+                    val: Cow::Borrowed(val),
+                    multiline: multiline,
+                }
+            );
             assert!(t.next().unwrap().is_none());
         }
 
@@ -585,7 +618,11 @@ mod tests {
         t(r#""\U000A0000""#, "\u{A0000}", false);
         t(r#""\\t""#, "\\t", false);
         t("\"\"\"\\\n\"\"\"", "", true);
-        t("\"\"\"\\\n     \t   \t  \\\r\n  \t \n  \t \r\n\"\"\"", "", true);
+        t(
+            "\"\"\"\\\n     \t   \t  \\\r\n  \t \n  \t \r\n\"\"\"",
+            "",
+            true,
+        );
         t(r#""\r""#, "\r", false);
         t(r#""\n""#, "\n", false);
         t(r#""\b""#, "\u{8}", false);
@@ -636,39 +673,45 @@ mod tests {
             assert_eq!(actual.len(), expected.len());
         }
 
-        t(" a ", &[
-            ((0, 1), Token::Whitespace(" "), " "),
-            ((1, 2), Token::Keylike("a"), "a"),
-            ((2, 3), Token::Whitespace(" "), " "),
-        ]);
-
-        t(" a\t [[]] \t [] {} , . =\n# foo \r\n#foo \n ", &[
-            ((0, 1), Token::Whitespace(" "), " "),
-            ((1, 2), Token::Keylike("a"), "a"),
-            ((2, 4), Token::Whitespace("\t "), "\t "),
-            ((4, 5), Token::LeftBracket, "["),
-            ((5, 6), Token::LeftBracket, "["),
-            ((6, 7), Token::RightBracket, "]"),
-            ((7, 8), Token::RightBracket, "]"),
-            ((8, 11), Token::Whitespace(" \t "), " \t "),
-            ((11, 12), Token::LeftBracket, "["),
-            ((12, 13), Token::RightBracket, "]"),
-            ((13, 14), Token::Whitespace(" "), " "),
-            ((14, 15), Token::LeftBrace, "{"),
-            ((15, 16), Token::RightBrace, "}"),
-            ((16, 17), Token::Whitespace(" "), " "),
-            ((17, 18), Token::Comma, ","),
-            ((18, 19), Token::Whitespace(" "), " "),
-            ((19, 20), Token::Period, "."),
-            ((20, 21), Token::Whitespace(" "), " "),
-            ((21, 22), Token::Equals, "="),
-            ((22, 23), Token::Newline, "\n"),
-            ((23, 29), Token::Comment("# foo "), "# foo "),
-            ((29, 31), Token::Newline, "\r\n"),
-            ((31, 36), Token::Comment("#foo "), "#foo "),
-            ((36, 37), Token::Newline, "\n"),
-            ((37, 38), Token::Whitespace(" "), " "),
-        ]);
+        t(
+            " a ",
+            &[
+                ((0, 1), Token::Whitespace(" "), " "),
+                ((1, 2), Token::Keylike("a"), "a"),
+                ((2, 3), Token::Whitespace(" "), " "),
+            ],
+        );
+
+        t(
+            " a\t [[]] \t [] {} , . =\n# foo \r\n#foo \n ",
+            &[
+                ((0, 1), Token::Whitespace(" "), " "),
+                ((1, 2), Token::Keylike("a"), "a"),
+                ((2, 4), Token::Whitespace("\t "), "\t "),
+                ((4, 5), Token::LeftBracket, "["),
+                ((5, 6), Token::LeftBracket, "["),
+                ((6, 7), Token::RightBracket, "]"),
+                ((7, 8), Token::RightBracket, "]"),
+                ((8, 11), Token::Whitespace(" \t "), " \t "),
+                ((11, 12), Token::LeftBracket, "["),
+                ((12, 13), Token::RightBracket, "]"),
+                ((13, 14), Token::Whitespace(" "), " "),
+                ((14, 15), Token::LeftBrace, "{"),
+                ((15, 16), Token::RightBrace, "}"),
+                ((16, 17), Token::Whitespace(" "), " "),
+                ((17, 18), Token::Comma, ","),
+                ((18, 19), Token::Whitespace(" "), " "),
+                ((19, 20), Token::Period, "."),
+                ((20, 21), Token::Whitespace(" "), " "),
+                ((21, 22), Token::Equals, "="),
+                ((22, 23), Token::Newline, "\n"),
+                ((23, 29), Token::Comment("# foo "), "# foo "),
+                ((29, 31), Token::Newline, "\r\n"),
+                ((31, 36), Token::Comment("#foo "), "#foo "),
+                ((36, 37), Token::Newline, "\n"),
+                ((37, 38), Token::Whitespace(" "), " "),
+            ],
+        );
     }
 
     #[test]
diff --git a/src/value.rs b/src/value.rs
index 2e42dc3..ee952b6 100644
--- a/src/value.rs
+++ b/src/value.rs
@@ -1,18 +1,18 @@
 //! Definition of a TOML value
 
 use std::collections::{BTreeMap, HashMap};
-use std::hash::Hash;
 use std::fmt;
+use std::hash::Hash;
 use std::ops;
 use std::str::FromStr;
 use std::vec;
 
-use serde::ser;
 use serde::de;
 use serde::de::IntoDeserializer;
+use serde::ser;
 
-pub use datetime::{Datetime, DatetimeParseError};
 use datetime::{self, DatetimeFromString};
+pub use datetime::{Datetime, DatetimeParseError};
 
 /// Representation of a TOML value.
 #[derive(PartialEq, Clone, Debug)]
@@ -46,7 +46,8 @@ impl Value {
     /// This conversion can fail if `T`'s implementation of `Serialize` decides to
     /// fail, or if `T` contains a map with non-string keys.
     pub fn try_from<T>(value: T) -> Result<Value, ::ser::Error>
-        where T: ser::Serialize,
+    where
+        T: ser::Serialize,
     {
         value.serialize(Serializer)
     }
@@ -61,7 +62,8 @@ impl Value {
     /// missing from the TOML map or some number is too big to fit in the expected
     /// primitive type.
     pub fn try_into<'de, T>(self) -> Result<T, ::de::Error>
-        where T: de::Deserialize<'de>,
+    where
+        T: de::Deserialize<'de>,
     {
         de::Deserialize::deserialize(self)
     }
@@ -92,7 +94,10 @@ impl Value {
 
     /// Extracts the integer value if it is an integer.
     pub fn as_integer(&self) -> Option<i64> {
-        match *self { Value::Integer(i) => Some(i), _ => None }
+        match *self {
+            Value::Integer(i) => Some(i),
+            _ => None,
+        }
     }
 
     /// Tests whether this value is an integer.
@@ -102,7 +107,10 @@ impl Value {
 
     /// Extracts the float value if it is a float.
     pub fn as_float(&self) -> Option<f64> {
-        match *self { Value::Float(f) => Some(f), _ => None }
+        match *self {
+            Value::Float(f) => Some(f),
+            _ => None,
+        }
     }
 
     /// Tests whether this value is a float.
@@ -112,7 +120,10 @@ impl Value {
 
     /// Extracts the boolean value if it is a boolean.
     pub fn as_bool(&self) -> Option<bool> {
-        match *self { Value::Boolean(b) => Some(b), _ => None }
+        match *self {
+            Value::Boolean(b) => Some(b),
+            _ => None,
+        }
     }
 
     /// Tests whether this value is a boolean.
@@ -122,7 +133,10 @@ impl Value {
 
     /// Extracts the string of this value if it is a string.
     pub fn as_str(&self) -> Option<&str> {
-        match *self { Value::String(ref s) => Some(&**s), _ => None }
+        match *self {
+            Value::String(ref s) => Some(&**s),
+            _ => None,
+        }
     }
 
     /// Tests if this value is a string.
@@ -139,7 +153,10 @@ impl Value {
     /// 1979-05-27T07:32:00Z
     /// ```
     pub fn as_datetime(&self) -> Option<&Datetime> {
-        match *self { Value::Datetime(ref s) => Some(s), _ => None }
+        match *self {
+            Value::Datetime(ref s) => Some(s),
+            _ => None,
+        }
     }
 
     /// Tests whether this value is a datetime.
@@ -149,12 +166,18 @@ impl Value {
 
     /// Extracts the array value if it is an array.
     pub fn as_array(&self) -> Option<&Vec<Value>> {
-        match *self { Value::Array(ref s) => Some(s), _ => None }
+        match *self {
+            Value::Array(ref s) => Some(s),
+            _ => None,
+        }
     }
 
     /// Extracts the array value if it is an array.
     pub fn as_array_mut(&mut self) -> Option<&mut Vec<Value>> {
-        match *self { Value::Array(ref mut s) => Some(s), _ => None }
+        match *self {
+            Value::Array(ref mut s) => Some(s),
+            _ => None,
+        }
     }
 
     /// Tests whether this value is an array.
@@ -164,12 +187,18 @@ impl Value {
 
     /// Extracts the table value if it is a table.
     pub fn as_table(&self) -> Option<&Table> {
-        match *self { Value::Table(ref s) => Some(s), _ => None }
+        match *self {
+            Value::Table(ref s) => Some(s),
+            _ => None,
+        }
     }
 
     /// Extracts the table value if it is a table.
     pub fn as_table_mut(&mut self) -> Option<&mut Table> {
-        match *self { Value::Table(ref mut s) => Some(s), _ => None }
+        match *self {
+            Value::Table(ref mut s) => Some(s),
+            _ => None,
+        }
     }
 
     /// Tests whether this value is a table.
@@ -180,13 +209,13 @@ impl Value {
     /// Tests whether this and another value have the same type.
     pub fn same_type(&self, other: &Value) -> bool {
         match (self, other) {
-            (&Value::String(..), &Value::String(..)) |
-            (&Value::Integer(..), &Value::Integer(..)) |
-            (&Value::Float(..), &Value::Float(..)) |
-            (&Value::Boolean(..), &Value::Boolean(..)) |
-            (&Value::Datetime(..), &Value::Datetime(..)) |
-            (&Value::Array(..), &Value::Array(..)) |
-            (&Value::Table(..), &Value::Table(..)) => true,
+            (&Value::String(..), &Value::String(..))
+            | (&Value::Integer(..), &Value::Integer(..))
+            | (&Value::Float(..), &Value::Float(..))
+            | (&Value::Boolean(..), &Value::Boolean(..))
+            | (&Value::Datetime(..), &Value::Datetime(..))
+            | (&Value::Array(..), &Value::Array(..))
+            | (&Value::Table(..), &Value::Table(..)) => true,
 
             _ => false,
         }
@@ -206,7 +235,10 @@ impl Value {
     }
 }
 
-impl<I> ops::Index<I> for Value where I: Index {
+impl<I> ops::Index<I> for Value
+where
+    I: Index,
+{
     type Output = Value;
 
     fn index(&self, index: I) -> &Value {
@@ -214,7 +246,10 @@ impl<I> ops::Index<I> for Value where I: Index {
     }
 }
 
-impl<I> ops::IndexMut<I> for Value where I: Index {
+impl<I> ops::IndexMut<I> for Value
+where
+    I: Index,
+{
     fn index_mut(&mut self, index: I) -> &mut Value {
         self.get_mut(index).expect("index not found")
     }
@@ -235,9 +270,7 @@ impl<V: Into<Value>> From<Vec<V>> for Value {
 
 impl<S: Into<String>, V: Into<Value>> From<BTreeMap<S, V>> for Value {
     fn from(val: BTreeMap<S, V>) -> Value {
-        let table = val.into_iter()
-            .map(|(s, v)| (s.into(), v.into()))
-            .collect();
+        let table = val.into_iter().map(|(s, v)| (s.into(), v.into())).collect();
 
         Value::Table(table)
     }
@@ -245,9 +278,7 @@ impl<S: Into<String>, V: Into<Value>> From<BTreeMap<S, V>> for Value {
 
 impl<S: Into<String> + Hash + Eq, V: Into<Value>> From<HashMap<S, V>> for Value {
     fn from(val: HashMap<S, V>) -> Value {
-        let table = val.into_iter()
-            .map(|(s, v)| (s.into(), v.into()))
-            .collect();
+        let table = val.into_iter().map(|(s, v)| (s.into(), v.into())).collect();
 
         Value::Table(table)
     }
@@ -261,7 +292,7 @@ macro_rules! impl_into_value {
                 Value::$variant(val.into())
             }
         }
-    }
+    };
 }
 
 impl_into_value!(String: String);
@@ -340,7 +371,10 @@ impl Index for String {
     }
 }
 
-impl<'s, T: ?Sized> Index for &'s T where T: Index {
+impl<'s, T: ?Sized> Index for &'s T
+where
+    T: Index,
+{
     fn index<'a>(&self, val: &'a Value) -> Option<&'a Value> {
         (**self).index(val)
     }
@@ -352,7 +386,9 @@ impl<'s, T: ?Sized> Index for &'s T where T: Index {
 
 impl fmt::Display for Value {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        ::ser::to_string(self).expect("Unable to represent value as string").fmt(f)
+        ::ser::to_string(self)
+            .expect("Unable to represent value as string")
+            .fmt(f)
     }
 }
 
@@ -365,7 +401,8 @@ impl FromStr for Value {
 
 impl ser::Serialize for Value {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where S: ser::Serializer
+    where
+        S: ser::Serializer,
     {
         use serde::ser::SerializeMap;
 
@@ -381,13 +418,20 @@ impl ser::Serialize for Value {
                 // Be sure to visit non-tables first (and also non
                 // array-of-tables) as all keys must be emitted first.
                 for (k, v) in t {
-                    if !v.is_table() && !v.is_array() ||
-                       (v.as_array().map(|a| !a.iter().any(|v| v.is_table())).unwrap_or(false)) {
+                    if !v.is_table() && !v.is_array()
+                        || (v
+                            .as_array()
+                            .map(|a| !a.iter().any(|v| v.is_table()))
+                            .unwrap_or(false))
+                    {
                         map.serialize_entry(k, v)?;
                     }
                 }
                 for (k, v) in t {
-                    if v.as_array().map(|a| a.iter().any(|v| v.is_table())).unwrap_or(false) {
+                    if v.as_array()
+                        .map(|a| a.iter().any(|v| v.is_table()))
+                        .unwrap_or(false)
+                    {
                         map.serialize_entry(k, v)?;
                     }
                 }
@@ -404,7 +448,8 @@ impl ser::Serialize for Value {
 
 impl<'de> de::Deserialize<'de> for Value {
     fn deserialize<D>(deserializer: D) -> Result<Value, D::Error>
-        where D: de::Deserializer<'de>,
+    where
+        D: de::Deserializer<'de>,
     {
         struct ValueVisitor;
 
@@ -452,13 +497,15 @@ impl<'de> de::Deserialize<'de> for Value {
             }
 
             fn visit_some<D>(self, deserializer: D) -> Result<Value, D::Error>
-                where D: de::Deserializer<'de>,
+            where
+                D: de::Deserializer<'de>,
             {
                 de::Deserialize::deserialize(deserializer)
             }
 
             fn visit_seq<V>(self, mut visitor: V) -> Result<Value, V::Error>
-                where V: de::SeqAccess<'de>,
+            where
+                V: de::SeqAccess<'de>,
             {
                 let mut vec = Vec::new();
                 while let Some(elem) = visitor.next_element()? {
@@ -468,16 +515,15 @@ impl<'de> de::Deserialize<'de> for Value {
             }
 
             fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
-                where V: de::MapAccess<'de>,
+            where
+                V: de::MapAccess<'de>,
             {
                 let mut key = String::new();
-                let datetime = visitor.next_key_seed(DatetimeOrTable {
-                    key: &mut key,
-                })?;
+                let datetime = visitor.next_key_seed(DatetimeOrTable { key: &mut key })?;
                 match datetime {
                     Some(true) => {
                         let date: DatetimeFromString = visitor.next_value()?;
-                        return Ok(Value::Datetime(date.value))
+                        return Ok(Value::Datetime(date.value));
                     }
                     None => return Ok(Value::Table(BTreeMap::new())),
                     Some(false) => {}
@@ -487,7 +533,7 @@ impl<'de> de::Deserialize<'de> for Value {
                 while let Some(key) = visitor.next_key()? {
                     if map.contains_key(&key) {
                         let msg = format!("duplicate key: `{}`", key);
-                        return Err(de::Error::custom(msg))
+                        return Err(de::Error::custom(msg));
                     }
                     map.insert(key, visitor.next_value()?);
                 }
@@ -503,7 +549,8 @@ impl<'de> de::Deserializer<'de> for Value {
     type Error = ::de::Error;
 
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, ::de::Error>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         match self {
             Value::Boolean(v) => visitor.visit_bool(v),
@@ -548,14 +595,18 @@ impl<'de> de::Deserializer<'de> for Value {
     {
         match self {
             Value::String(variant) => visitor.visit_enum(variant.into_deserializer()),
-            _ => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"string only")),
+            _ => Err(de::Error::invalid_type(
+                de::Unexpected::UnitVariant,
+                &"string only",
+            )),
         }
     }
 
     // `None` is interpreted as a missing field so be sure to implement `Some`
     // as a present field.
     fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, ::de::Error>
-        where V: de::Visitor<'de>,
+    where
+        V: de::Visitor<'de>,
     {
         visitor.visit_some(self)
     }
@@ -563,9 +614,10 @@ impl<'de> de::Deserializer<'de> for Value {
     fn deserialize_newtype_struct<V>(
         self,
         _name: &'static str,
-        visitor: V
+        visitor: V,
     ) -> Result<V::Value, ::de::Error>
-        where V: de::Visitor<'de>
+    where
+        V: de::Visitor<'de>,
     {
         visitor.visit_newtype_struct(self)
     }
@@ -592,9 +644,9 @@ impl SeqDeserializer {
 impl<'de> de::SeqAccess<'de> for SeqDeserializer {
     type Error = ::de::Error;
 
-    fn next_element_seed<T>(&mut self, seed: T)
-                            -> Result<Option<T::Value>, ::de::Error>
-        where T: de::DeserializeSeed<'de>,
+    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ::de::Error>
+    where
+        T: de::DeserializeSeed<'de>,
     {
         match self.iter.next() {
             Some(value) => seed.deserialize(value).map(Some),
@@ -628,7 +680,8 @@ impl<'de> de::MapAccess<'de> for MapDeserializer {
     type Error = ::de::Error;
 
     fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ::de::Error>
-        where T: de::DeserializeSeed<'de>,
+    where
+        T: de::DeserializeSeed<'de>,
     {
         match self.iter.next() {
             Some((key, value)) => {
@@ -640,7 +693,8 @@ impl<'de> de::MapAccess<'de> for MapDeserializer {
     }
 
     fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, ::de::Error>
-        where T: de::DeserializeSeed<'de>,
+    where
+        T: de::DeserializeSeed<'de>,
     {
         let (key, res) = match self.value.take() {
             Some((key, value)) => (key, seed.deserialize(value)),
@@ -749,35 +803,39 @@ impl ser::Serializer for Serializer {
         Err(::ser::Error::UnsupportedType)
     }
 
-    fn serialize_unit_struct(self, _name: &'static str)
-                             -> Result<Value, ::ser::Error> {
+    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value, ::ser::Error> {
         Err(::ser::Error::UnsupportedType)
     }
 
-    fn serialize_unit_variant(self,
-                              _name: &'static str,
-                              _variant_index: u32,
-                              _variant: &'static str)
-                              -> Result<Value, ::ser::Error> {
+    fn serialize_unit_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+    ) -> Result<Value, ::ser::Error> {
         self.serialize_str(_variant)
     }
 
-    fn serialize_newtype_struct<T: ?Sized>(self,
-                                           _name: &'static str,
-                                           value: &T)
-                                           -> Result<Value, ::ser::Error>
-        where T: ser::Serialize,
+    fn serialize_newtype_struct<T: ?Sized>(
+        self,
+        _name: &'static str,
+        value: &T,
+    ) -> Result<Value, ::ser::Error>
+    where
+        T: ser::Serialize,
     {
         value.serialize(self)
     }
 
-    fn serialize_newtype_variant<T: ?Sized>(self,
-                                            _name: &'static str,
-                                            _variant_index: u32,
-                                            _variant: &'static str,
-                                            _value: &T)
-                                            -> Result<Value, ::ser::Error>
-        where T: ser::Serialize,
+    fn serialize_newtype_variant<T: ?Sized>(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _value: &T,
+    ) -> Result<Value, ::ser::Error>
+    where
+        T: ser::Serialize,
     {
         Err(::ser::Error::UnsupportedType)
     }
@@ -787,16 +845,15 @@ impl ser::Serializer for Serializer {
     }
 
     fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Value, ::ser::Error>
-        where T: ser::Serialize,
+    where
+        T: ser::Serialize,
     {
         value.serialize(self)
     }
 
-    fn serialize_seq(self, len: Option<usize>)
-                     -> Result<Self::SerializeSeq, ::ser::Error>
-    {
+    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, ::ser::Error> {
         Ok(SerializeVec {
-            vec: Vec::with_capacity(len.unwrap_or(0))
+            vec: Vec::with_capacity(len.unwrap_or(0)),
         })
     }
 
@@ -804,42 +861,46 @@ impl ser::Serializer for Serializer {
         self.serialize_seq(Some(len))
     }
 
-    fn serialize_tuple_struct(self, _name: &'static str, len: usize)
-                              -> Result<Self::SerializeTupleStruct, ::ser::Error> {
+    fn serialize_tuple_struct(
+        self,
+        _name: &'static str,
+        len: usize,
+    ) -> Result<Self::SerializeTupleStruct, ::ser::Error> {
         self.serialize_seq(Some(len))
     }
 
-    fn serialize_tuple_variant(self,
-                               _name: &'static str,
-                               _variant_index: u32,
-                               _variant: &'static str,
-                               len: usize)
-                               -> Result<Self::SerializeTupleVariant, ::ser::Error>
-    {
+    fn serialize_tuple_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        len: usize,
+    ) -> Result<Self::SerializeTupleVariant, ::ser::Error> {
         self.serialize_seq(Some(len))
     }
 
-    fn serialize_map(self, _len: Option<usize>)
-                     -> Result<Self::SerializeMap, ::ser::Error>
-    {
+    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, ::ser::Error> {
         Ok(SerializeMap {
             map: BTreeMap::new(),
             next_key: None,
         })
     }
 
-    fn serialize_struct(self, _name: &'static str, len: usize)
-                        -> Result<Self::SerializeStruct, ::ser::Error> {
+    fn serialize_struct(
+        self,
+        _name: &'static str,
+        len: usize,
+    ) -> Result<Self::SerializeStruct, ::ser::Error> {
         self.serialize_map(Some(len))
     }
 
-    fn serialize_struct_variant(self,
-                                _name: &'static str,
-                                _variant_index: u32,
-                                _variant: &'static str,
-                                _len: usize)
-                                -> Result<Self::SerializeStructVariant, ::ser::Error>
-    {
+    fn serialize_struct_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStructVariant, ::ser::Error> {
         Err(::ser::Error::UnsupportedType)
     }
 }
@@ -858,7 +919,8 @@ impl ser::SerializeSeq for SerializeVec {
     type Error = ::ser::Error;
 
     fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error>
-        where T: ser::Serialize
+    where
+        T: ser::Serialize,
     {
         self.vec.push(Value::try_from(value)?);
         Ok(())
@@ -874,7 +936,8 @@ impl ser::SerializeTuple for SerializeVec {
     type Error = ::ser::Error;
 
     fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error>
-        where T: ser::Serialize
+    where
+        T: ser::Serialize,
     {
         ser::SerializeSeq::serialize_element(self, value)
     }
@@ -889,7 +952,8 @@ impl ser::SerializeTupleStruct for SerializeVec {
     type Error = ::ser::Error;
 
     fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error>
-        where T: ser::Serialize
+    where
+        T: ser::Serialize,
     {
         ser::SerializeSeq::serialize_element(self, value)
     }
@@ -904,7 +968,8 @@ impl ser::SerializeTupleVariant for SerializeVec {
     type Error = ::ser::Error;
 
     fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error>
-        where T: ser::Serialize
+    where
+        T: ser::Serialize,
     {
         ser::SerializeSeq::serialize_element(self, value)
     }
@@ -919,7 +984,8 @@ impl ser::SerializeMap for SerializeMap {
     type Error = ::ser::Error;
 
     fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), ::ser::Error>
-        where T: ser::Serialize
+    where
+        T: ser::Serialize,
     {
         match Value::try_from(key)? {
             Value::String(s) => self.next_key = Some(s),
@@ -929,12 +995,15 @@ impl ser::SerializeMap for SerializeMap {
     }
 
     fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error>
-        where T: ser::Serialize
+    where
+        T: ser::Serialize,
     {
         let key = self.next_key.take();
         let key = key.expect("serialize_value called before serialize_key");
         match Value::try_from(value) {
-            Ok(value) => { self.map.insert(key, value); }
+            Ok(value) => {
+                self.map.insert(key, value);
+            }
             Err(::ser::Error::UnsupportedNone) => {}
             Err(e) => return Err(e),
         }
@@ -950,8 +1019,13 @@ impl ser::SerializeStruct for SerializeMap {
     type Ok = Value;
     type Error = ::ser::Error;
 
-    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), ::ser::Error>
-        where T: ser::Serialize
+    fn serialize_field<T: ?Sized>(
+        &mut self,
+        key: &'static str,
+        value: &T,
+    ) -> Result<(), ::ser::Error>
+    where
+        T: ser::Serialize,
     {
         ser::SerializeMap::serialize_key(self, key)?;
         ser::SerializeMap::serialize_value(self, value)
@@ -970,7 +1044,8 @@ impl<'a, 'de> de::DeserializeSeed<'de> for DatetimeOrTable<'a> {
     type Value = bool;
 
     fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-        where D: de::Deserializer<'de>
+    where
+        D: de::Deserializer<'de>,
     {
         deserializer.deserialize_any(self)
     }
@@ -984,7 +1059,8 @@ impl<'a, 'de> de::Visitor<'de> for DatetimeOrTable<'a> {
     }
 
     fn visit_str<E>(self, s: &str) -> Result<bool, E>
-        where E: de::Error,
+    where
+        E: de::Error,
     {
         if s == datetime::FIELD {
             Ok(true)
@@ -995,7 +1071,8 @@ impl<'a, 'de> de::Visitor<'de> for DatetimeOrTable<'a> {
     }
 
     fn visit_string<E>(self, s: String) -> Result<bool, E>
-        where E: de::Error,
+    where
+        E: de::Error,
     {
         if s == datetime::FIELD {
             Ok(true)