diff --git a/serde2/src/bin.rs b/serde2/src/bin.rs
index f154e705..8a49216e 100644
--- a/serde2/src/bin.rs
+++ b/serde2/src/bin.rs
@@ -4,8 +4,8 @@ use std::collections::HashMap;
 use std::option;
 use std::string;
 
-use serde2::de2;
-use serde2::de2::{Deserialize, Deserializer};
+use serde2::de;
+use serde2::de::{Deserialize, Deserializer};
 
 #[deriving(Show)]
 enum Token {
@@ -61,7 +61,7 @@ impl<Iter: Iterator<Token>> MyDeserializer<Iter> {
 impl<Iter: Iterator<Token>> Deserializer<Error> for MyDeserializer<Iter> {
     fn visit<
         R,
-        V: de2::Visitor<MyDeserializer<Iter>, R, Error>,
+        V: de::Visitor<MyDeserializer<Iter>, R, Error>,
     >(&mut self, visitor: &mut V) -> Result<R, Error> {
         match self.next() {
             Some(Null) => {
@@ -95,7 +95,7 @@ impl<Iter: Iterator<Token>> Deserializer<Error> for MyDeserializer<Iter> {
 
     fn visit_option<
         R,
-        V: de2::Visitor<MyDeserializer<Iter>, R, Error>,
+        V: de::Visitor<MyDeserializer<Iter>, R, Error>,
     >(&mut self, visitor: &mut V) -> Result<R, Error> {
         match self.peek() {
             Some(&Null) => {
@@ -133,7 +133,7 @@ struct MyOptionVisitor {
 
 impl<
     Iter: Iterator<Token>,
-> de2::OptionVisitor<MyDeserializer<Iter>, Error> for MyOptionVisitor {
+> de::OptionVisitor<MyDeserializer<Iter>, Error> for MyOptionVisitor {
     fn visit<
         T: Deserialize<MyDeserializer<Iter>, Error>,
     >(&mut self, d: &mut MyDeserializer<Iter>) -> Result<option::Option<T>, Error> {
@@ -153,7 +153,7 @@ struct MySeqVisitor {
 
 impl<
     Iter: Iterator<Token>,
-> de2::SeqVisitor<MyDeserializer<Iter>, Error> for MySeqVisitor {
+> de::SeqVisitor<MyDeserializer<Iter>, Error> for MySeqVisitor {
     fn visit<
         T: Deserialize<MyDeserializer<Iter>, Error>
     >(&mut self, d: &mut MyDeserializer<Iter>) -> Result<option::Option<T>, Error> {
@@ -192,7 +192,7 @@ struct MyMapVisitor {
 
 impl<
     Iter: Iterator<Token>,
-> de2::MapVisitor<MyDeserializer<Iter>, Error> for MyMapVisitor {
+> de::MapVisitor<MyDeserializer<Iter>, Error> for MyMapVisitor {
     fn visit<
         K: Deserialize<MyDeserializer<Iter>, Error>,
         V: Deserialize<MyDeserializer<Iter>, Error>,
@@ -233,7 +233,7 @@ impl<
 
 mod json {
     use std::collections::TreeMap;
-    use serde2::de2;
+    use serde2::de;
 
     #[deriving(Show)]
     pub enum Value {
@@ -246,16 +246,16 @@ mod json {
     }
 
     impl<
-        D: de2::Deserializer<E>,
+        D: de::Deserializer<E>,
         E,
-    > de2::Deserialize<D, E> for Value {
+    > de::Deserialize<D, E> for Value {
         fn deserialize(d: &mut D) -> Result<Value, E> {
             struct Visitor;
 
             impl<
-                D: de2::Deserializer<E>,
+                D: de::Deserializer<E>,
                 E,
-            > de2::Visitor<D, Value, E> for Visitor {
+            > de::Visitor<D, Value, E> for Visitor {
                 fn visit_null(&mut self, _d: &mut D) -> Result<Value, E> {
                     Ok(Null)
                 }
@@ -271,7 +271,7 @@ mod json {
                 */
 
                 fn visit_option<
-                    Visitor: de2::OptionVisitor<D, E>,
+                    Visitor: de::OptionVisitor<D, E>,
                 >(&mut self, d: &mut D, mut visitor: Visitor) -> Result<Value, E> {
                     match try!(visitor.visit(d)) {
                         Some(value) => Ok(value),
@@ -280,7 +280,7 @@ mod json {
                 }
 
                 fn visit_seq<
-                    Visitor: de2::SeqVisitor<D, E>,
+                    Visitor: de::SeqVisitor<D, E>,
                 >(&mut self, d: &mut D, mut visitor: Visitor) -> Result<Value, E> {
                     let (len, _) = visitor.size_hint(d);
                     let mut values = Vec::with_capacity(len);
@@ -300,7 +300,7 @@ mod json {
                 }
 
                 fn visit_map<
-                    Visitor: de2::MapVisitor<D, E>,
+                    Visitor: de::MapVisitor<D, E>,
                 >(&mut self, d: &mut D, mut visitor: Visitor) -> Result<Value, E> {
                     let mut values = TreeMap::new();
 
@@ -480,8 +480,8 @@ fn main() {
 
 /*
 use std::collections::TreeMap;
-use serde2::{Serialize, GatherTokens};
-use serde2::json;
+use serde::{Serialize, GatherTokens};
+use serde::json;
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -491,7 +491,7 @@ struct Foo {
     z: &'static str,
 }
 
-impl<S: serde2::VisitorState<R>, R> serde2::Serialize<S, R> for Foo {
+impl<S: serde::VisitorState<R>, R> serde::Serialize<S, R> for Foo {
     fn serialize(&self, state: &mut S) -> R {
         state.visit_named_map("Foo", FooSerialize {
             value: self,
@@ -505,7 +505,7 @@ struct FooSerialize<'a> {
     state: uint,
 }
 
-impl<'a, S: serde2::VisitorState<R>, R> serde2::Visitor<S, R> for FooSerialize<'a> {
+impl<'a, S: serde::VisitorState<R>, R> serde::Visitor<S, R> for FooSerialize<'a> {
     fn visit(&mut self, state: &mut S) -> Option<R> {
         match self.state {
             0 => {
diff --git a/serde2/src/de.rs b/serde2/src/de.rs
index 3b2f4672..cd667743 100644
--- a/serde2/src/de.rs
+++ b/serde2/src/de.rs
@@ -1,93 +1,359 @@
-pub trait Deserialize<S, E> {
-    fn deserialize(state: &mut S) -> Result<Self, E>;
-}
+use std::collections::{HashMap, TreeMap};
+use std::hash::Hash;
 
 ///////////////////////////////////////////////////////////////////////////////
 
-pub trait Deserializer<D, R> {
-    fn deserialize<T: Deserialize<D, R>>(&mut self) -> R;
-
+pub trait Deserialize<D, E> {
+    fn deserialize(d: &mut D) -> Result<Self, E>;
 }
 
-///////////////////////////////////////////////////////////////////////////////
+pub trait Deserializer<E> {
+    fn visit<
+        R,
+        V: Visitor<Self, R, E>,
+    >(&mut self, visitor: &mut V) -> Result<R, E>;
 
-pub trait Visitor<D, R> {
-    fn visit(&mut self, state: &mut S) -> Option<R>;
+    fn visit_option<
+        R,
+        V: Visitor<Self, R, E>,
+    >(&mut self, visitor: &mut V) -> Result<R, E> {
+        self.visit(visitor)
+    }
+
+    fn syntax_error(&mut self) -> E;
+
+    fn end_of_stream_error(&mut self) -> E;
+}
+
+pub trait Visitor<D: Deserializer<E>, R, E> {
+    fn visit_null(&mut self, d: &mut D) -> Result<R, E> {
+        Err(d.syntax_error())
+    }
+
+    fn visit_int(&mut self, d: &mut D, _v: int) -> Result<R, E> {
+        Err(d.syntax_error())
+    }
+
+    fn visit_str(&mut self, d: &mut D, v: &str) -> Result<R, E> {
+        self.visit_string(d, v.to_string())
+    }
+
+    fn visit_string(&mut self, d: &mut D, _v: String) -> Result<R, E> {
+        Err(d.syntax_error())
+    }
+
+    fn visit_option<
+        V: OptionVisitor<D, E>,
+    >(&mut self, d: &mut D, _visitor: V) -> Result<R, E> {
+        Err(d.syntax_error())
+    }
+
+    fn visit_seq<
+        V: SeqVisitor<D, E>,
+    >(&mut self, d: &mut D, _visitor: V) -> Result<R, E> {
+        Err(d.syntax_error())
+    }
+
+    fn visit_map<
+        V: MapVisitor<D, E>,
+    >(&mut self, d: &mut D, _visitor: V) -> Result<R, E> {
+        Err(d.syntax_error())
+    }
+}
+
+pub trait OptionVisitor<D, E> {
+    fn visit<
+        T: Deserialize<D, E>,
+    >(&mut self, d: &mut D) -> Result<Option<T>, E>;
+}
+
+pub trait SeqVisitor<D, E> {
+    fn visit<
+        T: Deserialize<D, E>,
+    >(&mut self, d: &mut D) -> Result<Option<T>, E>;
+
+    fn end(&mut self, d: &mut D) -> Result<(), E>;
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
+    fn size_hint(&self, _d: &mut D) -> (uint, Option<uint>) {
         (0, None)
     }
 }
 
-pub trait SeqVisitor {
+pub trait MapVisitor<D, E> {
+    fn visit<
+        K: Deserialize<D, E>,
+        V: Deserialize<D, E>,
+    >(&mut self, d: &mut D) -> Result<Option<(K, V)>, E>;
 
-}
+    fn end(&mut self, d: &mut D) -> Result<(), E>;
 
-pub trait VisitorState<E> {
-    fn syntax_error(&mut self) -> E;
-
-    fn visit_int(&mut self) -> Result<int, E> {
+    #[inline]
+    fn size_hint(&self, _d: &mut D) -> (uint, Option<uint>) {
+        (0, None)
     }
-
-    fn visit_seq<Iter: FromIterator>(&mut self, ) -> Iter
-
 }
 
-
-
-
-
-
-
-
-
-
-
 ///////////////////////////////////////////////////////////////////////////////
 
-impl<D: VisitorState<E>, E> Deserialize<D, E> for int {
-    #[inline]
-    fn deserialize(state: &mut D) -> Result<int, E> {
-        state.visit_int()
+impl<
+    D: Deserializer<E>,
+    E,
+> Deserialize<D, E> for () {
+    fn deserialize(d: &mut D) -> Result<(), E> {
+        struct Visitor;
+
+        impl<D: Deserializer<E>, E> self::Visitor<D, (), E> for Visitor {
+            fn visit_null(&mut self, _d: &mut D) -> Result<(), E> {
+                Ok(())
+            }
+        }
+
+        d.visit(&mut Visitor)
     }
 }
 
+///////////////////////////////////////////////////////////////////////////////
+
+impl<
+    D: Deserializer<E>,
+    E,
+> Deserialize<D, E> for int {
+    fn deserialize(d: &mut D) -> Result<int, E> {
+        struct Visitor;
+
+        impl<D: Deserializer<E>, E> self::Visitor<D, int, E> for Visitor {
+            fn visit_int(&mut self, _d: &mut D, v: int) -> Result<int, E> {
+                Ok(v)
+            }
+        }
+
+        d.visit(&mut Visitor)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl<
+    D: Deserializer<E>,
+    E,
+> Deserialize<D, E> for String {
+    fn deserialize(d: &mut D) -> Result<String, E> {
+        struct Visitor;
+
+        impl<D: Deserializer<E>, E> self::Visitor<D, String, E> for Visitor {
+            fn visit_string(&mut self, _d: &mut D, v: String) -> Result<String, E> {
+                Ok(v)
+            }
+        }
+
+        d.visit(&mut Visitor)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
 
 impl<
     T: Deserialize<D, E>,
-    D: VisitorState<E>,
-    E
-> Deserialize<D, E> for Vec<T> {
-    #[inline]
-    fn deserialize(state: &mut D) -> Result<int, E> {
-        struct SeqVisitor {
+    D: Deserializer<E>,
+    E,
+> Deserialize<D, E> for Option<T> {
+    fn deserialize(d: &mut D) -> Result<Option<T>, E> {
+        struct Visitor;
 
+        impl<
+            T: Deserialize<D, E>,
+            D: Deserializer<E>,
+            E,
+        > self::Visitor<D, Option<T>, E> for Visitor {
+            fn visit_option<
+                V: OptionVisitor<D, E>,
+            >(&mut self, d: &mut D, mut visitor: V) -> Result<Option<T>, E> {
+                visitor.visit(d)
+            }
         }
 
-        impl SeqVisitor {
-            fn visit_seq<V: Visitor<Self>>(len: uint, visitor: V) {
-                let mut value = Vec::with_capacity(len);
+        d.visit_option(&mut Visitor)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl<
+    T: Deserialize<D, E>,
+    D: Deserializer<E>,
+    E,
+> Deserialize<D, E> for Vec<T> {
+    fn deserialize(d: &mut D) -> Result<Vec<T>, E> {
+        struct Visitor;
+
+        impl<
+            T: Deserialize<D, E>,
+            D: Deserializer<E>,
+            E,
+        > self::Visitor<D, Vec<T>, E> for Visitor {
+            fn visit_seq<
+                V: SeqVisitor<D, E>,
+            >(&mut self, d: &mut D, mut visitor: V) -> Result<Vec<T>, E> {
+                let (len, _) = visitor.size_hint(d);
+                let mut values = Vec::with_capacity(len);
 
                 loop {
-                    match visitor.visit(self, &mut value) {
-                        Some(()) => { }
-                        None => { break; }
+                    match try!(visitor.visit(d)) {
+                        Some(value) => {
+                            values.push(value);
+                        }
+                        None => {
+                            break;
+                        }
                     }
                 }
 
-                value
-            }
-
-            fn visit_seq_elt<
-                T: S
-            >(&mut self, value: &mut Vec<T>) {
-                let v = Deserialize
-                value.push(
+                Ok(values)
             }
         }
 
-        let v = Vec::new();
-        state.visit_seq()
+        d.visit(&mut Visitor)
+    }
+}
+
+impl<
+    T0: Deserialize<D, E>,
+    T1: Deserialize<D, E>,
+    D: Deserializer<E>,
+    E,
+> Deserialize<D, E> for (T0, T1) {
+    fn deserialize(d: &mut D) -> Result<(T0, T1), E> {
+        struct Visitor;
+
+        impl<
+            T0: Deserialize<D, E>,
+            T1: Deserialize<D, E>,
+            D: Deserializer<E>,
+            E,
+        > self::Visitor<D, (T0, T1), E> for Visitor {
+            fn visit_seq<
+                V: SeqVisitor<D, E>,
+            >(&mut self, d: &mut D, mut visitor: V) -> Result<(T0, T1), E> {
+                let mut state = 0u;
+                let mut t0 = None;
+                let mut t1 = None;
+
+                loop {
+                    match state {
+                        0 => {
+                            state += 1;
+                            match try!(visitor.visit(d)) {
+                                Some(value) => {
+                                    t0 = Some(value);
+                                }
+                                None => {
+                                    return Err(d.end_of_stream_error());
+                                }
+                            }
+                        }
+                        1 => {
+                            state += 1;
+                            match try!(visitor.visit(d)) {
+                                Some(value) => {
+                                    t1 = Some(value);
+                                }
+                                None => {
+                                    return Err(d.end_of_stream_error());
+                                }
+                            }
+                        }
+                        _ => {
+                            try!(visitor.end(d));
+
+                            return Ok((t0.unwrap(), t1.unwrap()));
+                        }
+                    }
+                }
+            }
+        }
+
+        d.visit(&mut Visitor)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl<
+    K: Deserialize<D, E> + Eq + Hash,
+    V: Deserialize<D, E>,
+    D: Deserializer<E>,
+    E,
+> Deserialize<D, E> for HashMap<K, V> {
+    fn deserialize(d: &mut D) -> Result<HashMap<K, V>, E> {
+        struct Visitor;
+
+        impl<
+            K: Deserialize<D, E> + Eq + Hash,
+            V: Deserialize<D, E>,
+            D: Deserializer<E>,
+            E,
+        > self::Visitor<D, HashMap<K, V>, E> for Visitor {
+            fn visit_map<
+                Visitor: MapVisitor<D, E>,
+            >(&mut self, d: &mut D, mut visitor: Visitor) -> Result<HashMap<K, V>, E> {
+                let (len, _) = visitor.size_hint(d);
+                let mut values = HashMap::with_capacity(len);
+
+                loop {
+                    match try!(visitor.visit(d)) {
+                        Some((key, value)) => {
+                            values.insert(key, value);
+                        }
+                        None => {
+                            break;
+                        }
+                    }
+                }
+
+                Ok(values)
+            }
+        }
+
+        d.visit(&mut Visitor)
+    }
+}
+
+impl<
+    K: Deserialize<D, E> + Eq + Ord,
+    V: Deserialize<D, E>,
+    D: Deserializer<E>,
+    E,
+> Deserialize<D, E> for TreeMap<K, V> {
+    fn deserialize(d: &mut D) -> Result<TreeMap<K, V>, E> {
+        struct Visitor;
+
+        impl<
+            K: Deserialize<D, E> + Eq + Ord,
+            V: Deserialize<D, E>,
+            D: Deserializer<E>,
+            E,
+        > self::Visitor<D, TreeMap<K, V>, E> for Visitor {
+            fn visit_map<
+                Visitor: MapVisitor<D, E>,
+            >(&mut self, d: &mut D, mut visitor: Visitor) -> Result<TreeMap<K, V>, E> {
+                let mut values = TreeMap::new();
+
+                loop {
+                    match try!(visitor.visit(d)) {
+                        Some((key, value)) => {
+                            values.insert(key, value);
+                        }
+                        None => {
+                            break;
+                        }
+                    }
+                }
+
+                Ok(values)
+            }
+        }
+
+        d.visit(&mut Visitor)
     }
 }
diff --git a/serde2/src/de2.rs b/serde2/src/de2.rs
deleted file mode 100644
index cd667743..00000000
--- a/serde2/src/de2.rs
+++ /dev/null
@@ -1,359 +0,0 @@
-use std::collections::{HashMap, TreeMap};
-use std::hash::Hash;
-
-///////////////////////////////////////////////////////////////////////////////
-
-pub trait Deserialize<D, E> {
-    fn deserialize(d: &mut D) -> Result<Self, E>;
-}
-
-pub trait Deserializer<E> {
-    fn visit<
-        R,
-        V: Visitor<Self, R, E>,
-    >(&mut self, visitor: &mut V) -> Result<R, E>;
-
-    fn visit_option<
-        R,
-        V: Visitor<Self, R, E>,
-    >(&mut self, visitor: &mut V) -> Result<R, E> {
-        self.visit(visitor)
-    }
-
-    fn syntax_error(&mut self) -> E;
-
-    fn end_of_stream_error(&mut self) -> E;
-}
-
-pub trait Visitor<D: Deserializer<E>, R, E> {
-    fn visit_null(&mut self, d: &mut D) -> Result<R, E> {
-        Err(d.syntax_error())
-    }
-
-    fn visit_int(&mut self, d: &mut D, _v: int) -> Result<R, E> {
-        Err(d.syntax_error())
-    }
-
-    fn visit_str(&mut self, d: &mut D, v: &str) -> Result<R, E> {
-        self.visit_string(d, v.to_string())
-    }
-
-    fn visit_string(&mut self, d: &mut D, _v: String) -> Result<R, E> {
-        Err(d.syntax_error())
-    }
-
-    fn visit_option<
-        V: OptionVisitor<D, E>,
-    >(&mut self, d: &mut D, _visitor: V) -> Result<R, E> {
-        Err(d.syntax_error())
-    }
-
-    fn visit_seq<
-        V: SeqVisitor<D, E>,
-    >(&mut self, d: &mut D, _visitor: V) -> Result<R, E> {
-        Err(d.syntax_error())
-    }
-
-    fn visit_map<
-        V: MapVisitor<D, E>,
-    >(&mut self, d: &mut D, _visitor: V) -> Result<R, E> {
-        Err(d.syntax_error())
-    }
-}
-
-pub trait OptionVisitor<D, E> {
-    fn visit<
-        T: Deserialize<D, E>,
-    >(&mut self, d: &mut D) -> Result<Option<T>, E>;
-}
-
-pub trait SeqVisitor<D, E> {
-    fn visit<
-        T: Deserialize<D, E>,
-    >(&mut self, d: &mut D) -> Result<Option<T>, E>;
-
-    fn end(&mut self, d: &mut D) -> Result<(), E>;
-
-    #[inline]
-    fn size_hint(&self, _d: &mut D) -> (uint, Option<uint>) {
-        (0, None)
-    }
-}
-
-pub trait MapVisitor<D, E> {
-    fn visit<
-        K: Deserialize<D, E>,
-        V: Deserialize<D, E>,
-    >(&mut self, d: &mut D) -> Result<Option<(K, V)>, E>;
-
-    fn end(&mut self, d: &mut D) -> Result<(), E>;
-
-    #[inline]
-    fn size_hint(&self, _d: &mut D) -> (uint, Option<uint>) {
-        (0, None)
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-impl<
-    D: Deserializer<E>,
-    E,
-> Deserialize<D, E> for () {
-    fn deserialize(d: &mut D) -> Result<(), E> {
-        struct Visitor;
-
-        impl<D: Deserializer<E>, E> self::Visitor<D, (), E> for Visitor {
-            fn visit_null(&mut self, _d: &mut D) -> Result<(), E> {
-                Ok(())
-            }
-        }
-
-        d.visit(&mut Visitor)
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-impl<
-    D: Deserializer<E>,
-    E,
-> Deserialize<D, E> for int {
-    fn deserialize(d: &mut D) -> Result<int, E> {
-        struct Visitor;
-
-        impl<D: Deserializer<E>, E> self::Visitor<D, int, E> for Visitor {
-            fn visit_int(&mut self, _d: &mut D, v: int) -> Result<int, E> {
-                Ok(v)
-            }
-        }
-
-        d.visit(&mut Visitor)
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-impl<
-    D: Deserializer<E>,
-    E,
-> Deserialize<D, E> for String {
-    fn deserialize(d: &mut D) -> Result<String, E> {
-        struct Visitor;
-
-        impl<D: Deserializer<E>, E> self::Visitor<D, String, E> for Visitor {
-            fn visit_string(&mut self, _d: &mut D, v: String) -> Result<String, E> {
-                Ok(v)
-            }
-        }
-
-        d.visit(&mut Visitor)
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-impl<
-    T: Deserialize<D, E>,
-    D: Deserializer<E>,
-    E,
-> Deserialize<D, E> for Option<T> {
-    fn deserialize(d: &mut D) -> Result<Option<T>, E> {
-        struct Visitor;
-
-        impl<
-            T: Deserialize<D, E>,
-            D: Deserializer<E>,
-            E,
-        > self::Visitor<D, Option<T>, E> for Visitor {
-            fn visit_option<
-                V: OptionVisitor<D, E>,
-            >(&mut self, d: &mut D, mut visitor: V) -> Result<Option<T>, E> {
-                visitor.visit(d)
-            }
-        }
-
-        d.visit_option(&mut Visitor)
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-impl<
-    T: Deserialize<D, E>,
-    D: Deserializer<E>,
-    E,
-> Deserialize<D, E> for Vec<T> {
-    fn deserialize(d: &mut D) -> Result<Vec<T>, E> {
-        struct Visitor;
-
-        impl<
-            T: Deserialize<D, E>,
-            D: Deserializer<E>,
-            E,
-        > self::Visitor<D, Vec<T>, E> for Visitor {
-            fn visit_seq<
-                V: SeqVisitor<D, E>,
-            >(&mut self, d: &mut D, mut visitor: V) -> Result<Vec<T>, E> {
-                let (len, _) = visitor.size_hint(d);
-                let mut values = Vec::with_capacity(len);
-
-                loop {
-                    match try!(visitor.visit(d)) {
-                        Some(value) => {
-                            values.push(value);
-                        }
-                        None => {
-                            break;
-                        }
-                    }
-                }
-
-                Ok(values)
-            }
-        }
-
-        d.visit(&mut Visitor)
-    }
-}
-
-impl<
-    T0: Deserialize<D, E>,
-    T1: Deserialize<D, E>,
-    D: Deserializer<E>,
-    E,
-> Deserialize<D, E> for (T0, T1) {
-    fn deserialize(d: &mut D) -> Result<(T0, T1), E> {
-        struct Visitor;
-
-        impl<
-            T0: Deserialize<D, E>,
-            T1: Deserialize<D, E>,
-            D: Deserializer<E>,
-            E,
-        > self::Visitor<D, (T0, T1), E> for Visitor {
-            fn visit_seq<
-                V: SeqVisitor<D, E>,
-            >(&mut self, d: &mut D, mut visitor: V) -> Result<(T0, T1), E> {
-                let mut state = 0u;
-                let mut t0 = None;
-                let mut t1 = None;
-
-                loop {
-                    match state {
-                        0 => {
-                            state += 1;
-                            match try!(visitor.visit(d)) {
-                                Some(value) => {
-                                    t0 = Some(value);
-                                }
-                                None => {
-                                    return Err(d.end_of_stream_error());
-                                }
-                            }
-                        }
-                        1 => {
-                            state += 1;
-                            match try!(visitor.visit(d)) {
-                                Some(value) => {
-                                    t1 = Some(value);
-                                }
-                                None => {
-                                    return Err(d.end_of_stream_error());
-                                }
-                            }
-                        }
-                        _ => {
-                            try!(visitor.end(d));
-
-                            return Ok((t0.unwrap(), t1.unwrap()));
-                        }
-                    }
-                }
-            }
-        }
-
-        d.visit(&mut Visitor)
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-impl<
-    K: Deserialize<D, E> + Eq + Hash,
-    V: Deserialize<D, E>,
-    D: Deserializer<E>,
-    E,
-> Deserialize<D, E> for HashMap<K, V> {
-    fn deserialize(d: &mut D) -> Result<HashMap<K, V>, E> {
-        struct Visitor;
-
-        impl<
-            K: Deserialize<D, E> + Eq + Hash,
-            V: Deserialize<D, E>,
-            D: Deserializer<E>,
-            E,
-        > self::Visitor<D, HashMap<K, V>, E> for Visitor {
-            fn visit_map<
-                Visitor: MapVisitor<D, E>,
-            >(&mut self, d: &mut D, mut visitor: Visitor) -> Result<HashMap<K, V>, E> {
-                let (len, _) = visitor.size_hint(d);
-                let mut values = HashMap::with_capacity(len);
-
-                loop {
-                    match try!(visitor.visit(d)) {
-                        Some((key, value)) => {
-                            values.insert(key, value);
-                        }
-                        None => {
-                            break;
-                        }
-                    }
-                }
-
-                Ok(values)
-            }
-        }
-
-        d.visit(&mut Visitor)
-    }
-}
-
-impl<
-    K: Deserialize<D, E> + Eq + Ord,
-    V: Deserialize<D, E>,
-    D: Deserializer<E>,
-    E,
-> Deserialize<D, E> for TreeMap<K, V> {
-    fn deserialize(d: &mut D) -> Result<TreeMap<K, V>, E> {
-        struct Visitor;
-
-        impl<
-            K: Deserialize<D, E> + Eq + Ord,
-            V: Deserialize<D, E>,
-            D: Deserializer<E>,
-            E,
-        > self::Visitor<D, TreeMap<K, V>, E> for Visitor {
-            fn visit_map<
-                Visitor: MapVisitor<D, E>,
-            >(&mut self, d: &mut D, mut visitor: Visitor) -> Result<TreeMap<K, V>, E> {
-                let mut values = TreeMap::new();
-
-                loop {
-                    match try!(visitor.visit(d)) {
-                        Some((key, value)) => {
-                            values.insert(key, value);
-                        }
-                        None => {
-                            break;
-                        }
-                    }
-                }
-
-                Ok(values)
-            }
-        }
-
-        d.visit(&mut Visitor)
-    }
-}
diff --git a/serde2/src/lib.rs b/serde2/src/lib.rs
index a5a0bbd5..91df934f 100644
--- a/serde2/src/lib.rs
+++ b/serde2/src/lib.rs
@@ -5,6 +5,5 @@
 //pub use ser::GatherTokens;
 
 pub mod ser;
-//pub mod de;
-pub mod de2;
+pub mod de;
 //pub mod json;