diff --git a/Cargo.toml b/Cargo.toml
index 675a958..0e12f9b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -19,8 +19,8 @@ categories = ["config", "encoding", "parser-implementations"]
 travis-ci = { repository = "alexcrichton/toml-rs" }
 
 [dependencies]
-serde = "0.9.6"
+serde = "1.0"
 
 [dev-dependencies]
-serde_derive = "0.9"
-serde_json = "0.9"
+serde_derive = "1.0"
+serde_json = "1.0"
diff --git a/src/datetime.rs b/src/datetime.rs
index b3c82d6..7917cad 100644
--- a/src/datetime.rs
+++ b/src/datetime.rs
@@ -315,13 +315,13 @@ impl ser::Serialize for Datetime {
     }
 }
 
-impl de::Deserialize for Datetime {
+impl<'de> de::Deserialize<'de> for Datetime {
     fn deserialize<D>(deserializer: D) -> Result<Datetime, D::Error>
-        where D: de::Deserializer
+        where D: de::Deserializer<'de>
     {
         struct DatetimeVisitor;
 
-        impl de::Visitor for DatetimeVisitor {
+        impl<'de> de::Visitor<'de> for DatetimeVisitor {
             type Value = Datetime;
 
             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -329,13 +329,13 @@ impl de::Deserialize for Datetime {
             }
 
             fn visit_map<V>(self, mut visitor: V) -> Result<Datetime, V::Error>
-                where V: de::MapVisitor
+                where V: de::MapAccess<'de>
             {
-                let value = visitor.visit_key::<DatetimeKey>()?;
+                let value = visitor.next_key::<DatetimeKey>()?;
                 if value.is_none() {
                     return Err(de::Error::custom("datetime key not found"))
                 }
-                let v: DatetimeFromString = visitor.visit_value()?;
+                let v: DatetimeFromString = visitor.next_value()?;
                 Ok(v.value)
 
             }
@@ -350,13 +350,13 @@ impl de::Deserialize for Datetime {
 
 struct DatetimeKey;
 
-impl de::Deserialize for DatetimeKey {
+impl<'de> de::Deserialize<'de> for DatetimeKey {
     fn deserialize<D>(deserializer: D) -> Result<DatetimeKey, D::Error>
-        where D: de::Deserializer
+        where D: de::Deserializer<'de>
     {
         struct FieldVisitor;
 
-        impl de::Visitor for FieldVisitor {
+        impl<'de> de::Visitor<'de> for FieldVisitor {
             type Value = ();
 
             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -374,7 +374,7 @@ impl de::Deserialize for DatetimeKey {
             }
         }
 
-        deserializer.deserialize_struct_field(FieldVisitor)?;
+        deserializer.deserialize_identifier(FieldVisitor)?;
         Ok(DatetimeKey)
     }
 }
@@ -383,13 +383,13 @@ pub struct DatetimeFromString {
     pub value: Datetime,
 }
 
-impl de::Deserialize for DatetimeFromString {
+impl<'de> de::Deserialize<'de> for DatetimeFromString {
     fn deserialize<D>(deserializer: D) -> Result<DatetimeFromString, D::Error>
-        where D: de::Deserializer
+        where D: de::Deserializer<'de>
     {
         struct Visitor;
 
-        impl de::Visitor for Visitor {
+        impl<'de> de::Visitor<'de> for Visitor {
             type Value = DatetimeFromString;
 
             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
diff --git a/src/de.rs b/src/de.rs
index 13a3d90..4578c9a 100644
--- a/src/de.rs
+++ b/src/de.rs
@@ -19,8 +19,8 @@ use datetime::{SERDE_STRUCT_FIELD_NAME, SERDE_STRUCT_NAME};
 ///
 /// This function will attempt to interpret `bytes` as UTF-8 data and then
 /// deserialize `T` from the TOML document provided.
-pub fn from_slice<T>(bytes: &[u8]) -> Result<T, Error>
-    where T: de::Deserialize,
+pub fn from_slice<'de, T>(bytes: &'de [u8]) -> Result<T, Error>
+    where T: de::Deserialize<'de>,
 {
     match str::from_utf8(bytes) {
         Ok(s) => from_str(s),
@@ -32,8 +32,8 @@ pub fn from_slice<T>(bytes: &[u8]) -> Result<T, Error>
 ///
 /// This function will attempt to interpret `s` as a TOML document and
 /// deserialize `T` from the document.
-pub fn from_str<T>(s: &str) -> Result<T, Error>
-    where T: de::Deserialize,
+pub fn from_str<'de, T>(s: &'de str) -> Result<T, Error>
+    where T: de::Deserialize<'de>,
 {
     let mut d = Deserializer::new(s);
     let ret = T::deserialize(&mut d)?;
@@ -132,11 +132,11 @@ pub struct Deserializer<'a> {
     tokens: Tokenizer<'a>,
 }
 
-impl<'a, 'b> de::Deserializer for &'b mut Deserializer<'a> {
+impl<'de, 'b> de::Deserializer<'de> for &'b mut Deserializer<'de> {
     type Error = Error;
 
-    fn deserialize<V>(self, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor<'de>,
     {
         let mut tables = Vec::new();
         let mut cur_table = Table {
@@ -192,10 +192,10 @@ impl<'a, 'b> de::Deserializer for &'b mut Deserializer<'a> {
         })
     }
 
-    forward_to_deserialize! {
+    forward_to_deserialize_any! {
         bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
-        seq_fixed_size bytes byte_buf map struct unit enum newtype_struct
-        struct_field ignored_any unit_struct tuple_struct tuple option
+        bytes byte_buf map struct unit enum newtype_struct
+        ignored_any unit_struct tuple_struct tuple option identifier
     }
 }
 
@@ -207,23 +207,23 @@ struct Table<'a> {
 }
 
 #[doc(hidden)]
-pub struct MapVisitor<'a: 'b, 'b> {
-    values: vec::IntoIter<(Cow<'a, str>, Value<'a>)>,
-    next_value: Option<(Cow<'a, str>, Value<'a>)>,
+pub struct MapVisitor<'de: 'b, 'b> {
+    values: vec::IntoIter<(Cow<'de, str>, Value<'de>)>,
+    next_value: Option<(Cow<'de, str>, Value<'de>)>,
     depth: usize,
     cur: usize,
     cur_parent: usize,
     max: usize,
-    tables: &'b mut [Table<'a>],
+    tables: &'b mut [Table<'de>],
     array: bool,
-    de: &'b mut Deserializer<'a>,
+    de: &'b mut Deserializer<'de>,
 }
 
-impl<'a, 'b> de::MapVisitor for MapVisitor<'a, 'b> {
+impl<'de, 'b> de::MapAccess<'de> for MapVisitor<'de, 'b> {
     type Error = Error;
 
-    fn visit_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
-        where K: de::DeserializeSeed,
+    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
+        where K: de::DeserializeSeed<'de>,
     {
         if self.cur_parent == self.max || self.cur == self.max {
             return Ok(None)
@@ -268,11 +268,11 @@ impl<'a, 'b> de::MapVisitor for MapVisitor<'a, 'b> {
             let table = &mut self.tables[pos];
 
             // If we're not yet at the appropriate depth for this table then we
-            // just visit the next portion of its header and then continue
+            // just next the next portion of its header and then continue
             // decoding.
             if self.depth != table.header.len() {
                 let key = &table.header[self.depth];
-                let key = seed.deserialize(StrDeserializer::new(key[..].into()))?;
+                let key = seed.deserialize(StrDeserializer::new(key.clone()))?;
                 return Ok(Some(key))
             }
 
@@ -289,8 +289,8 @@ impl<'a, 'b> de::MapVisitor for MapVisitor<'a, 'b> {
         }
     }
 
-    fn visit_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
-        where V: de::DeserializeSeed,
+    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
+        where V: de::DeserializeSeed<'de>,
     {
         if let Some((k, v)) = self.next_value.take() {
             match seed.deserialize(ValueDeserializer::new(v)) {
@@ -323,11 +323,11 @@ impl<'a, 'b> de::MapVisitor for MapVisitor<'a, 'b> {
     }
 }
 
-impl<'a, 'b> de::SeqVisitor for MapVisitor<'a, 'b> {
+impl<'de, 'b> de::SeqAccess<'de> for MapVisitor<'de, 'b> {
     type Error = Error;
 
-    fn visit_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
-        where K: de::DeserializeSeed,
+    fn next_element_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
+        where K: de::DeserializeSeed<'de>,
     {
         assert!(self.next_value.is_none());
         assert!(self.values.next().is_none());
@@ -361,11 +361,11 @@ impl<'a, 'b> de::SeqVisitor for MapVisitor<'a, 'b> {
     }
 }
 
-impl<'a, 'b> de::Deserializer for MapVisitor<'a, 'b> {
+impl<'de, 'b> de::Deserializer<'de> for MapVisitor<'de, 'b> {
     type Error = Error;
 
-    fn deserialize<V>(self, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor<'de>,
     {
         if self.array  {
             visitor.visit_seq(self)
@@ -377,15 +377,15 @@ impl<'a, 'b> de::Deserializer for MapVisitor<'a, '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
+        where V: de::Visitor<'de>,
     {
         visitor.visit_some(self)
     }
 
-    forward_to_deserialize! {
+    forward_to_deserialize_any! {
         bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
-        seq_fixed_size bytes byte_buf map struct unit newtype_struct
-        struct_field ignored_any unit_struct tuple_struct tuple enum
+        bytes byte_buf map struct unit newtype_struct identifier
+        ignored_any unit_struct tuple_struct tuple enum
     }
 }
 
@@ -401,22 +401,22 @@ impl<'a> StrDeserializer<'a> {
     }
 }
 
-impl<'a> de::Deserializer for StrDeserializer<'a> {
+impl<'de> de::Deserializer<'de> for StrDeserializer<'de> {
     type Error = Error;
 
-    fn deserialize<V>(self, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor<'de>,
     {
         match self.key {
-            Cow::Borrowed(s) => visitor.visit_str(s),
+            Cow::Borrowed(s) => visitor.visit_borrowed_str(s),
             Cow::Owned(s) => visitor.visit_string(s),
         }
     }
 
-    forward_to_deserialize! {
+    forward_to_deserialize_any! {
         bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
-        seq_fixed_size bytes byte_buf map struct option unit newtype_struct
-        struct_field ignored_any unit_struct tuple_struct tuple enum
+        bytes byte_buf map struct option unit newtype_struct
+        ignored_any unit_struct tuple_struct tuple enum identifier
     }
 }
 
@@ -432,17 +432,17 @@ impl<'a> ValueDeserializer<'a> {
     }
 }
 
-impl<'a> de::Deserializer for ValueDeserializer<'a> {
+impl<'de> de::Deserializer<'de> for ValueDeserializer<'de> {
     type Error = Error;
 
-    fn deserialize<V>(self, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor<'de>,
     {
         match self.value {
             Value::Integer(i) => visitor.visit_i64(i),
             Value::Boolean(b) => visitor.visit_bool(b),
             Value::Float(f) => visitor.visit_f64(f),
-            Value::String(Cow::Borrowed(s)) => visitor.visit_str(s),
+            Value::String(Cow::Borrowed(s)) => visitor.visit_borrowed_str(s),
             Value::String(Cow::Owned(s)) => visitor.visit_string(s),
             Value::Datetime(s) => visitor.visit_map(DatetimeDeserializer {
                 date: s,
@@ -467,7 +467,7 @@ impl<'a> de::Deserializer for ValueDeserializer<'a> {
                              name: &'static str,
                              fields: &'static [&'static str],
                              visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
+        where V: de::Visitor<'de>,
     {
         if name == SERDE_STRUCT_NAME && fields == &[SERDE_STRUCT_FIELD_NAME] {
             if let Value::Datetime(s) = self.value {
@@ -478,26 +478,26 @@ impl<'a> de::Deserializer for ValueDeserializer<'a> {
             }
         }
 
-        self.deserialize(visitor)
+        self.deserialize_any(visitor)
     }
 
     // `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
+        where V: de::Visitor<'de>,
     {
         visitor.visit_some(self)
     }
 
-    forward_to_deserialize! {
+    forward_to_deserialize_any! {
         bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
-        seq_fixed_size bytes byte_buf map unit newtype_struct
-        struct_field ignored_any unit_struct tuple_struct tuple enum
+        bytes byte_buf map unit newtype_struct identifier
+        ignored_any unit_struct tuple_struct tuple enum
     }
 }
 
-impl<'a> de::value::ValueDeserializer<Error> for Value<'a> {
-    type Deserializer = ValueDeserializer<'a>;
+impl<'de> de::IntoDeserializer<'de, Error> for Value<'de> {
+    type Deserializer = ValueDeserializer<'de>;
 
     fn into_deserializer(self) -> Self::Deserializer {
         ValueDeserializer::new(self)
@@ -509,11 +509,11 @@ struct DatetimeDeserializer<'a> {
     date: &'a str,
 }
 
-impl<'a> de::MapVisitor for DatetimeDeserializer<'a> {
+impl<'de> de::MapAccess<'de> for DatetimeDeserializer<'de> {
     type Error = Error;
 
-    fn visit_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
-        where K: de::DeserializeSeed,
+    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
+        where K: de::DeserializeSeed<'de>,
     {
         if self.visited {
             return Ok(None)
@@ -522,8 +522,8 @@ impl<'a> de::MapVisitor for DatetimeDeserializer<'a> {
         seed.deserialize(DatetimeFieldDeserializer).map(Some)
     }
 
-    fn visit_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
-        where V: de::DeserializeSeed,
+    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
+        where V: de::DeserializeSeed<'de>,
     {
         seed.deserialize(StrDeserializer::new(self.date.into()))
     }
@@ -531,19 +531,19 @@ impl<'a> de::MapVisitor for DatetimeDeserializer<'a> {
 
 struct DatetimeFieldDeserializer;
 
-impl de::Deserializer for DatetimeFieldDeserializer {
+impl<'de> de::Deserializer<'de> for DatetimeFieldDeserializer {
     type Error = Error;
 
-    fn deserialize<V>(self, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor<'de>,
     {
-        visitor.visit_str(SERDE_STRUCT_FIELD_NAME)
+        visitor.visit_borrowed_str(SERDE_STRUCT_FIELD_NAME)
     }
 
-    forward_to_deserialize! {
+    forward_to_deserialize_any! {
         bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
-        seq_fixed_size bytes byte_buf map struct option unit newtype_struct
-        struct_field ignored_any unit_struct tuple_struct tuple enum
+        bytes byte_buf map struct option unit newtype_struct
+        ignored_any unit_struct tuple_struct tuple enum identifier
     }
 }
 
@@ -552,11 +552,11 @@ struct InlineTableDeserializer<'a> {
     next_value: Option<Value<'a>>,
 }
 
-impl<'a> de::MapVisitor for InlineTableDeserializer<'a> {
+impl<'de> de::MapAccess<'de> for InlineTableDeserializer<'de> {
     type Error = Error;
 
-    fn visit_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
-        where K: de::DeserializeSeed,
+    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
+        where K: de::DeserializeSeed<'de>,
     {
         let (key, value) = match self.values.next() {
             Some(pair) => pair,
@@ -566,8 +566,8 @@ impl<'a> de::MapVisitor for InlineTableDeserializer<'a> {
         seed.deserialize(StrDeserializer::new(key)).map(Some)
     }
 
-    fn visit_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
-        where V: de::DeserializeSeed,
+    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
+        where V: de::DeserializeSeed<'de>,
     {
         let value = self.next_value.take().expect("Unable to read table values");
         seed.deserialize(ValueDeserializer::new(value))
diff --git a/src/ser.rs b/src/ser.rs
index 8fcf0eb..e4b62f7 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -420,7 +420,7 @@ impl<'a, 'b> ser::Serializer for &'b mut Serializer<'a> {
 
     fn serialize_unit_variant(self,
                               _name: &'static str,
-                              _variant_index: usize,
+                              _variant_index: u32,
                               _variant: &'static str)
                               -> Result<(), Self::Error> {
         Err(Error::UnsupportedType)
@@ -435,7 +435,7 @@ impl<'a, 'b> ser::Serializer for &'b mut Serializer<'a> {
 
     fn serialize_newtype_variant<T: ?Sized>(self,
                                             _name: &'static str,
-                                            _variant_index: usize,
+                                            _variant_index: u32,
                                             _variant: &'static str,
                                             _value: &T)
                                             -> Result<(), Self::Error>
@@ -454,11 +454,6 @@ impl<'a, 'b> ser::Serializer for &'b mut Serializer<'a> {
         })
     }
 
-    fn serialize_seq_fixed_size(self, size: usize)
-                                -> Result<Self::SerializeSeq, Self::Error> {
-        self.serialize_seq(Some(size))
-    }
-
     fn serialize_tuple(self, _len: usize)
                        -> Result<Self::SerializeTuple, Self::Error> {
         Err(Error::UnsupportedType)
@@ -471,7 +466,7 @@ impl<'a, 'b> ser::Serializer for &'b mut Serializer<'a> {
 
     fn serialize_tuple_variant(self,
                                _name: &'static str,
-                               _variant_index: usize,
+                               _variant_index: u32,
                                _variant: &'static str,
                                _len: usize)
                                -> Result<Self::SerializeTupleVariant, Self::Error> {
@@ -507,7 +502,7 @@ impl<'a, 'b> ser::Serializer for &'b mut Serializer<'a> {
 
     fn serialize_struct_variant(self,
                                 _name: &'static str,
-                                _variant_index: usize,
+                                _variant_index: u32,
                                 _variant: &'static str,
                                 _len: usize)
                                 -> Result<Self::SerializeStructVariant, Self::Error> {
@@ -754,7 +749,7 @@ impl<'a, 'b> ser::Serializer for DateStrEmitter<'a, 'b> {
 
     fn serialize_unit_variant(self,
                               _name: &'static str,
-                              _variant_index: usize,
+                              _variant_index: u32,
                               _variant: &'static str)
                               -> Result<(), Self::Error> {
         Err(Error::DateInvalid)
@@ -769,7 +764,7 @@ impl<'a, 'b> ser::Serializer for DateStrEmitter<'a, 'b> {
 
     fn serialize_newtype_variant<T: ?Sized>(self,
                                             _name: &'static str,
-                                            _variant_index: usize,
+                                            _variant_index: u32,
                                             _variant: &'static str,
                                             _value: &T)
                                             -> Result<(), Self::Error>
@@ -783,11 +778,6 @@ impl<'a, 'b> ser::Serializer for DateStrEmitter<'a, 'b> {
         Err(Error::DateInvalid)
     }
 
-    fn serialize_seq_fixed_size(self, _size: usize)
-                                -> Result<Self::SerializeSeq, Self::Error> {
-        Err(Error::DateInvalid)
-    }
-
     fn serialize_tuple(self, _len: usize)
                        -> Result<Self::SerializeTuple, Self::Error> {
         Err(Error::DateInvalid)
@@ -800,7 +790,7 @@ impl<'a, 'b> ser::Serializer for DateStrEmitter<'a, 'b> {
 
     fn serialize_tuple_variant(self,
                                _name: &'static str,
-                               _variant_index: usize,
+                               _variant_index: u32,
                                _variant: &'static str,
                                _len: usize)
                                -> Result<Self::SerializeTupleVariant, Self::Error> {
@@ -819,7 +809,7 @@ impl<'a, 'b> ser::Serializer for DateStrEmitter<'a, 'b> {
 
     fn serialize_struct_variant(self,
                                 _name: &'static str,
-                                _variant_index: usize,
+                                _variant_index: u32,
                                 _variant: &'static str,
                                 _len: usize)
                                 -> Result<Self::SerializeStructVariant, Self::Error> {
@@ -918,7 +908,7 @@ impl ser::Serializer for StringExtractor {
 
     fn serialize_unit_variant(self,
                               _name: &'static str,
-                              _variant_index: usize,
+                              _variant_index: u32,
                               _variant: &'static str)
                               -> Result<String, Self::Error> {
         Err(Error::KeyNotString)
@@ -933,7 +923,7 @@ impl ser::Serializer for StringExtractor {
 
     fn serialize_newtype_variant<T: ?Sized>(self,
                                             _name: &'static str,
-                                            _variant_index: usize,
+                                            _variant_index: u32,
                                             _variant: &'static str,
                                             _value: &T)
                                             -> Result<String, Self::Error>
@@ -947,11 +937,6 @@ impl ser::Serializer for StringExtractor {
         Err(Error::KeyNotString)
     }
 
-    fn serialize_seq_fixed_size(self, _size: usize)
-                                -> Result<Self::SerializeSeq, Self::Error> {
-        Err(Error::KeyNotString)
-    }
-
     fn serialize_tuple(self, _len: usize)
                        -> Result<Self::SerializeTuple, Self::Error> {
         Err(Error::KeyNotString)
@@ -964,7 +949,7 @@ impl ser::Serializer for StringExtractor {
 
     fn serialize_tuple_variant(self,
                                _name: &'static str,
-                               _variant_index: usize,
+                               _variant_index: u32,
                                _variant: &'static str,
                                _len: usize)
                                -> Result<Self::SerializeTupleVariant, Self::Error> {
@@ -983,7 +968,7 @@ impl ser::Serializer for StringExtractor {
 
     fn serialize_struct_variant(self,
                                 _name: &'static str,
-                                _variant_index: usize,
+                                _variant_index: u32,
                                 _variant: &'static str,
                                 _len: usize)
                                 -> Result<Self::SerializeStructVariant, Self::Error> {
@@ -1175,7 +1160,7 @@ impl<E: ser::Error> ser::Serializer for Categorize<E> {
         Err(ser::Error::custom("unsupported"))
     }
 
-    fn serialize_unit_variant(self, _: &'static str, _: usize, _: &'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"))
     }
 
@@ -1183,7 +1168,7 @@ impl<E: ser::Error> ser::Serializer for Categorize<E> {
         v.serialize(self)
     }
 
-    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(self, _: &'static str, _: usize, _: &'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"))
     }
 
@@ -1191,10 +1176,6 @@ impl<E: ser::Error> ser::Serializer for Categorize<E> {
         Ok(self)
     }
 
-    fn serialize_seq_fixed_size(self, _: usize) -> Result<Self, Self::Error> {
-        Ok(self)
-    }
-
     fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self::Error> {
         Err(ser::Error::custom("unsupported"))
     }
@@ -1203,7 +1184,7 @@ impl<E: ser::Error> ser::Serializer for Categorize<E> {
         Err(ser::Error::custom("unsupported"))
     }
 
-    fn serialize_tuple_variant(self, _: &'static str, _: usize, _: &'static str, _: usize) -> Result<Self::SerializeTupleVariant, Self::Error> {
+    fn serialize_tuple_variant(self, _: &'static str, _: u32, _: &'static str, _: usize) -> Result<Self::SerializeTupleVariant, Self::Error> {
         Err(ser::Error::custom("unsupported"))
     }
 
@@ -1215,7 +1196,7 @@ impl<E: ser::Error> ser::Serializer for Categorize<E> {
         Ok(self)
     }
 
-    fn serialize_struct_variant(self, _: &'static str, _: usize, _: &'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"))
     }
 }
diff --git a/src/value.rs b/src/value.rs
index 5c59437..7c2b3eb 100644
--- a/src/value.rs
+++ b/src/value.rs
@@ -58,8 +58,8 @@ impl Value {
     /// something is wrong with the data, for example required struct fields are
     /// missing from the TOML map or some number is too big to fit in the expected
     /// primitive type.
-    pub fn try_into<T>(self) -> Result<T, ::de::Error>
-        where T: de::Deserialize,
+    pub fn try_into<'de, T>(self) -> Result<T, ::de::Error>
+        where T: de::Deserialize<'de>,
     {
         de::Deserialize::deserialize(self)
     }
@@ -387,13 +387,13 @@ impl ser::Serialize for Value {
     }
 }
 
-impl de::Deserialize for Value {
+impl<'de> de::Deserialize<'de> for Value {
     fn deserialize<D>(deserializer: D) -> Result<Value, D::Error>
-        where D: de::Deserializer
+        where D: de::Deserializer<'de>,
     {
         struct ValueVisitor;
 
-        impl de::Visitor for ValueVisitor {
+        impl<'de> de::Visitor<'de> for ValueVisitor {
             type Value = Value;
 
             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -421,55 +421,58 @@ impl de::Deserialize for Value {
             }
 
             fn visit_some<D>(self, deserializer: D) -> Result<Value, D::Error>
-                where D: de::Deserializer,
+                where D: de::Deserializer<'de>,
             {
                 de::Deserialize::deserialize(deserializer)
             }
 
-            fn visit_seq<V>(self, visitor: V) -> Result<Value, V::Error>
-                where V: de::SeqVisitor
+            fn visit_seq<V>(self, mut visitor: V) -> Result<Value, V::Error>
+                where V: de::SeqAccess<'de>,
             {
-                let values = de::impls::VecVisitor::new().visit_seq(visitor)?;
-                Ok(Value::Array(values))
+                let mut vec = Vec::new();
+                while let Some(elem) = try!(visitor.next_element()) {
+                    vec.push(elem);
+                }
+                Ok(Value::Array(vec))
             }
 
             fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
-                where V: de::MapVisitor
+                where V: de::MapAccess<'de>,
             {
                 let mut key = String::new();
-                let datetime = visitor.visit_key_seed(DatetimeOrTable {
+                let datetime = visitor.next_key_seed(DatetimeOrTable {
                     key: &mut key,
                 })?;
                 match datetime {
                     Some(true) => {
-                        let date: DatetimeFromString = visitor.visit_value()?;
+                        let date: DatetimeFromString = visitor.next_value()?;
                         return Ok(Value::Datetime(date.value))
                     }
                     None => return Ok(Value::Table(BTreeMap::new())),
                     Some(false) => {}
                 }
                 let mut map = BTreeMap::new();
-                map.insert(key, visitor.visit_value()?);
-                while let Some(key) = visitor.visit_key()? {
+                map.insert(key, visitor.next_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))
                     }
-                    map.insert(key, visitor.visit_value()?);
+                    map.insert(key, visitor.next_value()?);
                 }
                 Ok(Value::Table(map))
             }
         }
 
-        deserializer.deserialize(ValueVisitor)
+        deserializer.deserialize_any(ValueVisitor)
     }
 }
 
-impl de::Deserializer for Value {
+impl<'de> de::Deserializer<'de> for Value {
     type Error = ::de::Error;
 
-    fn deserialize<V>(self, visitor: V) -> Result<V::Value, ::de::Error>
-        where V: de::Visitor,
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, ::de::Error>
+        where V: de::Visitor<'de>,
     {
         match self {
             Value::Boolean(v) => visitor.visit_bool(v),
@@ -505,15 +508,15 @@ impl de::Deserializer for Value {
     // `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
+        where V: de::Visitor<'de>,
     {
         visitor.visit_some(self)
     }
 
-    forward_to_deserialize! {
+    forward_to_deserialize_any! {
         bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit seq
-        seq_fixed_size bytes byte_buf map unit_struct tuple_struct struct
-        struct_field tuple ignored_any enum newtype_struct
+        bytes byte_buf map unit_struct tuple_struct struct
+        tuple ignored_any enum newtype_struct identifier
     }
 }
 
@@ -529,11 +532,12 @@ impl SeqDeserializer {
     }
 }
 
-impl de::SeqVisitor for SeqDeserializer {
+impl<'de> de::SeqAccess<'de> for SeqDeserializer {
     type Error = ::de::Error;
 
-    fn visit_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ::de::Error>
-        where T: de::DeserializeSeed,
+    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),
@@ -541,8 +545,11 @@ impl de::SeqVisitor for SeqDeserializer {
         }
     }
 
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
+    fn size_hint(&self) -> Option<usize> {
+        match self.iter.size_hint() {
+            (lower, Some(upper)) if lower == upper => Some(upper),
+            _ => None,
+        }
     }
 }
 
@@ -560,11 +567,11 @@ impl MapDeserializer {
     }
 }
 
-impl de::MapVisitor for MapDeserializer {
+impl<'de> de::MapAccess<'de> for MapDeserializer {
     type Error = ::de::Error;
 
-    fn visit_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ::de::Error>
-        where T: de::DeserializeSeed,
+    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ::de::Error>
+        where T: de::DeserializeSeed<'de>,
     {
         match self.iter.next() {
             Some((key, value)) => {
@@ -575,8 +582,8 @@ impl de::MapVisitor for MapDeserializer {
         }
     }
 
-    fn visit_value_seed<T>(&mut self, seed: T) -> Result<T::Value, ::de::Error>
-        where T: de::DeserializeSeed,
+    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, ::de::Error>
+        where T: de::DeserializeSeed<'de>,
     {
         let (key, res) = match self.value.take() {
             Some((key, value)) => (key, seed.deserialize(value)),
@@ -588,8 +595,11 @@ impl de::MapVisitor for MapDeserializer {
         })
     }
 
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
+    fn size_hint(&self) -> Option<usize> {
+        match self.iter.size_hint() {
+            (lower, Some(upper)) if lower == upper => Some(upper),
+            _ => None,
+        }
     }
 }
 
@@ -681,7 +691,7 @@ impl ser::Serializer for Serializer {
 
     fn serialize_unit_variant(self,
                               _name: &'static str,
-                              _variant_index: usize,
+                              _variant_index: u32,
                               _variant: &'static str)
                               -> Result<Value, ::ser::Error> {
         Err(::ser::Error::UnsupportedType)
@@ -698,7 +708,7 @@ impl ser::Serializer for Serializer {
 
     fn serialize_newtype_variant<T: ?Sized>(self,
                                             _name: &'static str,
-                                            _variant_index: usize,
+                                            _variant_index: u32,
                                             _variant: &'static str,
                                             _value: &T)
                                             -> Result<Value, ::ser::Error>
@@ -725,11 +735,6 @@ impl ser::Serializer for Serializer {
         })
     }
 
-    fn serialize_seq_fixed_size(self, size: usize)
-                                -> Result<Self::SerializeSeq, ::ser::Error> {
-        self.serialize_seq(Some(size))
-    }
-
     fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, ::ser::Error> {
         Err(::ser::Error::UnsupportedType)
     }
@@ -741,7 +746,7 @@ impl ser::Serializer for Serializer {
 
     fn serialize_tuple_variant(self,
                                _name: &'static str,
-                               _variant_index: usize,
+                               _variant_index: u32,
                                _variant: &'static str,
                                _len: usize)
                                -> Result<Self::SerializeTupleVariant, ::ser::Error>
@@ -765,7 +770,7 @@ impl ser::Serializer for Serializer {
 
     fn serialize_struct_variant(self,
                                 _name: &'static str,
-                                _variant_index: usize,
+                                _variant_index: u32,
                                 _variant: &'static str,
                                 _len: usize)
                                 -> Result<Self::SerializeStructVariant, ::ser::Error>
@@ -851,17 +856,17 @@ struct DatetimeOrTable<'a> {
     key: &'a mut String,
 }
 
-impl<'a> de::DeserializeSeed for DatetimeOrTable<'a> {
+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
+        where D: de::Deserializer<'de>
     {
-        deserializer.deserialize(self)
+        deserializer.deserialize_any(self)
     }
 }
 
-impl<'a> de::Visitor for DatetimeOrTable<'a> {
+impl<'a, 'de> de::Visitor<'de> for DatetimeOrTable<'a> {
     type Value = bool;
 
     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
diff --git a/tests/serde.rs b/tests/serde.rs
index e4d88fc..bfbdc6f 100644
--- a/tests/serde.rs
+++ b/tests/serde.rs
@@ -130,8 +130,8 @@ fn nested() {
 fn application_decode_error() {
     #[derive(PartialEq, Debug)]
     struct Range10(usize);
-    impl Deserialize for Range10 {
-         fn deserialize<D: Deserializer>(d: D) -> Result<Range10, D::Error> {
+    impl<'de> Deserialize<'de> for Range10 {
+         fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Range10, D::Error> {
              let x: usize = try!(Deserialize::deserialize(d));
              if x > 10 {
                  Err(serde::de::Error::custom("more than 10"))