diff --git a/serde2/serde2_macros/src/lib.rs b/serde2/serde2_macros/src/lib.rs
index e0dd752b..74cd2375 100644
--- a/serde2/serde2_macros/src/lib.rs
+++ b/serde2/serde2_macros/src/lib.rs
@@ -57,7 +57,7 @@ fn expand_derive_serialize(
     sp: Span,
     mitem: &MetaItem,
     item: &Item,
-    mut push: Box<FnMut(P<ast::Item>)>
+    push: &mut FnMut(P<ast::Item>)
 ) {
     let inline = cx.meta_word(sp, token::InternedString::new("inline"));
     let attrs = vec!(cx.attribute(sp, inline));
@@ -462,7 +462,7 @@ pub fn expand_derive_deserialize(
     sp: Span,
     mitem: &MetaItem,
     item: &Item,
-    mut push: Box<FnMut(P<ast::Item>)>
+    push: &mut FnMut(P<ast::Item>)
 ) {
     let inline = cx.meta_word(sp, token::InternedString::new("inline"));
     let attrs = vec!(cx.attribute(sp, inline));
diff --git a/serde2/src/de.rs b/serde2/src/de.rs
index 0cd139c8..1af3a0fd 100644
--- a/serde2/src/de.rs
+++ b/serde2/src/de.rs
@@ -1,4 +1,4 @@
-use std::collections::hash_map::Hasher;
+use std::marker::PhantomData;
 use std::collections::{HashMap, BTreeMap};
 use std::hash::Hash;
 use std::num::FromPrimitive;
@@ -357,7 +357,9 @@ macro_rules! impl_deserialize_num_method {
     }
 }
 
-pub struct PrimitiveVisitor<T>;
+pub struct PrimitiveVisitor<T> {
+    marker: PhantomData<T>,
+}
 
 impl<
     T: Deserialize + FromPrimitive
@@ -385,7 +387,7 @@ macro_rules! impl_deserialize_num {
             fn deserialize<
                 D: Deserializer,
             >(deserializer: &mut D) -> Result<$ty, D::Error> {
-                deserializer.visit(&mut PrimitiveVisitor)
+                deserializer.visit(&mut PrimitiveVisitor { marker: PhantomData })
             }
         }
     }
@@ -474,7 +476,9 @@ impl Deserialize for String {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-struct OptionVisitor<T>;
+struct OptionVisitor<T> {
+    marker: PhantomData<T>,
+}
 
 impl<
     T: Deserialize,
@@ -500,13 +504,15 @@ impl<T> Deserialize for Option<T> where T: Deserialize {
     fn deserialize<
         D: Deserializer,
     >(deserializer: &mut D) -> Result<Option<T>, D::Error> {
-        deserializer.visit_option(&mut OptionVisitor)
+        deserializer.visit_option(&mut OptionVisitor { marker: PhantomData })
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-struct VecVisitor<T>;
+struct VecVisitor<T> {
+    marker: PhantomData<T>,
+}
 
 impl<T> Visitor for VecVisitor<T> where T: Deserialize {
     type Value = Vec<T>;
@@ -529,7 +535,7 @@ impl<T: Deserialize> Deserialize for Vec<T> {
     fn deserialize<
         D: Deserializer,
     >(deserializer: &mut D) -> Result<Vec<T>, D::Error> {
-        deserializer.visit(&mut VecVisitor)
+        deserializer.visit(&mut VecVisitor { marker: PhantomData })
     }
 }
 
@@ -539,7 +545,9 @@ macro_rules! tuple_impls {
     () => {};
     ($($visitor:ident => ($($name:ident),+),)+) => {
         $(
-            struct $visitor<$($name,)+>;
+            struct $visitor<$($name,)+> {
+                marker: PhantomData<($($name,)+)>,
+            }
 
             impl<
                 $($name: Deserialize,)+
@@ -571,7 +579,7 @@ macro_rules! tuple_impls {
                 fn deserialize<
                     D: Deserializer,
                 >(deserializer: &mut D) -> Result<($($name,)+), D::Error> {
-                    deserializer.visit(&mut $visitor)
+                    deserializer.visit(&mut $visitor { marker: PhantomData })
                 }
             }
         )+
@@ -595,10 +603,12 @@ tuple_impls! {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-struct HashMapVisitor<K, V>;
+struct HashMapVisitor<K, V> {
+    marker: PhantomData<HashMap<K, V>>,
+}
 
 impl<K, V> Visitor for HashMapVisitor<K, V>
-    where K: Deserialize + Eq + Hash<Hasher>,
+    where K: Deserialize + Eq + Hash,
           V: Deserialize,
 {
     type Value = HashMap<K, V>;
@@ -619,19 +629,21 @@ impl<K, V> Visitor for HashMapVisitor<K, V>
 }
 
 impl<K, V> Deserialize for HashMap<K, V>
-    where K: Deserialize + Eq + Hash<Hasher>,
+    where K: Deserialize + Eq + Hash,
           V: Deserialize,
 {
     fn deserialize<
         D: Deserializer,
     >(deserializer: &mut D) -> Result<HashMap<K, V>, D::Error> {
-        deserializer.visit(&mut HashMapVisitor)
+        deserializer.visit(&mut HashMapVisitor { marker: PhantomData })
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-struct BTreeMapVisitor<K, V>;
+struct BTreeMapVisitor<K, V> {
+    marker: PhantomData<BTreeMap<K, V>>,
+}
 
 impl<K, V> Visitor for BTreeMapVisitor<K, V>
     where K: Deserialize + Ord,
@@ -660,7 +672,7 @@ impl<
     fn deserialize<
         D: Deserializer,
     >(deserializer: &mut D) -> Result<BTreeMap<K, V>, D::Error> {
-        deserializer.visit(&mut BTreeMapVisitor)
+        deserializer.visit(&mut BTreeMapVisitor { marker: PhantomData })
     }
 }
 
@@ -1339,28 +1351,28 @@ mod tests {
             false => vec![Token::Bool(false)],
         }
         test_isize {
-            0is => vec![Token::Isize(0)],
-            0is => vec![Token::I8(0)],
-            0is => vec![Token::I16(0)],
-            0is => vec![Token::I32(0)],
-            0is => vec![Token::I64(0)],
-            0is => vec![Token::Usize(0)],
-            0is => vec![Token::U8(0)],
-            0is => vec![Token::U16(0)],
-            0is => vec![Token::U32(0)],
-            0is => vec![Token::U64(0)],
-            0is => vec![Token::F32(0.)],
-            0is => vec![Token::F64(0.)],
+            0isize => vec![Token::Isize(0)],
+            0isize => vec![Token::I8(0)],
+            0isize => vec![Token::I16(0)],
+            0isize => vec![Token::I32(0)],
+            0isize => vec![Token::I64(0)],
+            0isize => vec![Token::Usize(0)],
+            0isize => vec![Token::U8(0)],
+            0isize => vec![Token::U16(0)],
+            0isize => vec![Token::U32(0)],
+            0isize => vec![Token::U64(0)],
+            0isize => vec![Token::F32(0.)],
+            0isize => vec![Token::F64(0.)],
         }
         test_ints {
-            0is => vec![Token::Isize(0)],
+            0isize => vec![Token::Isize(0)],
             0i8 => vec![Token::I8(0)],
             0i16 => vec![Token::I16(0)],
             0i32 => vec![Token::I32(0)],
             0i64 => vec![Token::I64(0)],
         }
         test_uints {
-            0us => vec![Token::Usize(0)],
+            0usize => vec![Token::Usize(0)],
             0u8 => vec![Token::U8(0)],
             0u16 => vec![Token::U16(0)],
             0u32 => vec![Token::U32(0)],
diff --git a/serde2/src/lib.rs b/serde2/src/lib.rs
index 0fd403e3..85fd10c5 100644
--- a/serde2/src/lib.rs
+++ b/serde2/src/lib.rs
@@ -1,4 +1,4 @@
-#![feature(core, hash, io, std_misc, unicode)]
+#![feature(core, io, std_misc, unicode)]
 
 extern crate unicode;
 
diff --git a/serde2/src/ser.rs b/serde2/src/ser.rs
index 3d198909..e0d26bcd 100644
--- a/serde2/src/ser.rs
+++ b/serde2/src/ser.rs
@@ -1,6 +1,6 @@
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::collections::hash_state::HashState;
-use std::hash::{Hash, Hasher};
+use std::hash::Hash;
 use std::rc::Rc;
 use std::str;
 use std::sync::Arc;
@@ -238,7 +238,7 @@ impl Serialize for String {
     fn visit<
         V: Visitor,
     >(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
-        (&self[]).visit(visitor)
+        (&self[..]).visit(visitor)
     }
 }
 
@@ -320,7 +320,7 @@ impl<
     fn visit<
         V: Visitor,
     >(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
-        (&self[]).visit(visitor)
+        (&self[..]).visit(visitor)
     }
 }
 
@@ -333,10 +333,9 @@ impl<T> Serialize for BTreeSet<T> where T: Serialize {
     }
 }
 
-impl<T, S, H> Serialize for HashSet<T, S>
-    where T: Serialize + Eq + Hash<H>,
-          S: HashState<Hasher=H>,
-          H: Hasher<Output=u64>,
+impl<T, S> Serialize for HashSet<T, S>
+    where T: Serialize + Eq + Hash,
+          S: HashState,
 {
     #[inline]
     fn visit<V: Visitor>(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
@@ -586,11 +585,10 @@ impl<K, V> Serialize for BTreeMap<K, V>
     }
 }
 
-impl<K, V, S, H> Serialize for HashMap<K, V, S>
-    where K: Serialize + Eq + Hash<H>,
+impl<K, V, S> Serialize for HashMap<K, V, S>
+    where K: Serialize + Eq + Hash,
           V: Serialize,
-          S: HashState<Hasher=H>,
-          H: Hasher<Output=u64>,
+          S: HashState,
 {
     #[inline]
     fn visit<V_: Visitor>(&self, visitor: &mut V_) -> Result<V_::Value, V_::Error> {