diff --git a/serde/src/ser/impls.rs b/serde/src/ser/impls.rs
index 25789356..734337e9 100644
--- a/serde/src/ser/impls.rs
+++ b/serde/src/ser/impls.rs
@@ -247,7 +247,7 @@ impl<'a, I> Serialize for Iterator<I>
         };
         let mut seq = try!(serializer.serialize_seq(size));
         for e in iter {
-            try!(seq.serialize_element(e));
+            try!(seq.serialize_element(&e));
         }
         seq.end()
     }
@@ -263,7 +263,7 @@ macro_rules! serialize_seq {
         {
             let mut seq = try!(serializer.serialize_seq(Some(self.len())));
             for e in self {
-                try!(seq.serialize_element(e));
+                try!(seq.serialize_element(&e));
             }
             seq.end()
         }
@@ -331,7 +331,7 @@ impl<A> Serialize for ops::Range<A>
     {
         let mut seq = try!(serializer.serialize_seq(Some(self.len())));
         for e in self.clone() {
-            try!(seq.serialize_element(e));
+            try!(seq.serialize_element(&e));
         }
         seq.end()
     }
@@ -348,7 +348,7 @@ impl<A> Serialize for ops::RangeInclusive<A>
     {
         let mut seq = try!(serializer.serialize_seq(Some(self.len())));
         for e in self.clone() {
-            try!(seq.serialize_element(e));
+            try!(seq.serialize_element(&e));
         }
         seq.end()
     }
@@ -696,8 +696,8 @@ impl Serialize for Duration {
     {
         use super::SerializeStruct;
         let mut state = try!(serializer.serialize_struct("Duration", 2));
-        try!(state.serialize_field("secs", self.as_secs()));
-        try!(state.serialize_field("nanos", self.subsec_nanos()));
+        try!(state.serialize_field("secs", &self.as_secs()));
+        try!(state.serialize_field("nanos", &self.subsec_nanos()));
         state.end()
     }
 }
diff --git a/serde/src/ser/mod.rs b/serde/src/ser/mod.rs
index 4131f0b2..f755579d 100644
--- a/serde/src/ser/mod.rs
+++ b/serde/src/ser/mod.rs
@@ -200,30 +200,30 @@ pub trait Serializer {
     /// struct, to be more efficiently serialized than a tuple struct with
     /// multiple items. A reasonable implementation would be to forward to
     /// `serialize_tuple_struct` or to just serialize the inner value without wrapping.
-    fn serialize_newtype_struct<T: Serialize>(
+    fn serialize_newtype_struct<T: ?Sized + Serialize>(
         self,
         name: &'static str,
-        value: T,
+        value: &T,
     ) -> Result<Self::Ok, Self::Error>;
 
     /// Allows a variant with a single item to be more efficiently serialized
     /// than a variant with multiple items. A reasonable implementation would be
     /// to forward to `serialize_tuple_variant`.
-    fn serialize_newtype_variant<T: Serialize>(
+    fn serialize_newtype_variant<T: ?Sized + Serialize>(
         self,
         name: &'static str,
         variant_index: usize,
         variant: &'static str,
-        value: T,
+        value: &T,
     ) -> Result<Self::Ok, Self::Error>;
 
     /// Serializes a `None` value.
     fn serialize_none(self) -> Result<Self::Ok, Self::Error>;
 
     /// Serializes a `Some(...)` value.
-    fn serialize_some<T: Serialize>(
+    fn serialize_some<T: ?Sized + Serialize>(
         self,
-        value: T,
+        value: &T,
     ) -> Result<Self::Ok, Self::Error>;
 
     /// Begins to serialize a sequence. This call must be followed by zero or
@@ -311,7 +311,7 @@ pub trait SerializeSeq {
     type Error: Error;
 
     /// Serializes a sequence element.
-    fn serialize_element<T: Serialize>(&mut self, value: T) -> Result<(), Self::Error>;
+    fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error>;
 
     /// Finishes serializing a sequence.
     fn end(self) -> Result<Self::Ok, Self::Error>;
@@ -327,7 +327,7 @@ pub trait SerializeTuple {
     type Error: Error;
 
     /// Serializes a tuple element.
-    fn serialize_element<T: Serialize>(&mut self, value: T) -> Result<(), Self::Error>;
+    fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error>;
 
     /// Finishes serializing a tuple.
     fn end(self) -> Result<Self::Ok, Self::Error>;
@@ -343,7 +343,7 @@ pub trait SerializeTupleStruct {
     type Error: Error;
 
     /// Serializes a tuple struct element.
-    fn serialize_field<T: Serialize>(&mut self, value: T) -> Result<(), Self::Error>;
+    fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error>;
 
     /// Finishes serializing a tuple struct.
     fn end(self) -> Result<Self::Ok, Self::Error>;
@@ -359,7 +359,7 @@ pub trait SerializeTupleVariant {
     type Error: Error;
 
     /// Serializes a tuple variant element.
-    fn serialize_field<T: Serialize>(&mut self, value: T) -> Result<(), Self::Error>;
+    fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error>;
 
     /// Finishes serializing a tuple variant.
     fn end(self) -> Result<Self::Ok, Self::Error>;
@@ -375,10 +375,10 @@ pub trait SerializeMap {
     type Error: Error;
 
     /// Serialize a map key.
-    fn serialize_key<T: Serialize>(&mut self, key: T) -> Result<(), Self::Error>;
+    fn serialize_key<T: ?Sized + Serialize>(&mut self, key: &T) -> Result<(), Self::Error>;
 
     /// Serialize a map value.
-    fn serialize_value<T: Serialize>(&mut self, value: T) -> Result<(), Self::Error>;
+    fn serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error>;
 
     /// Finishes serializing a map.
     fn end(self) -> Result<Self::Ok, Self::Error>;
@@ -394,7 +394,7 @@ pub trait SerializeStruct {
     type Error: Error;
 
     /// Serializes a struct field.
-    fn serialize_field<V: Serialize>(&mut self, key: &'static str, value: V) -> Result<(), Self::Error>;
+    fn serialize_field<T: ?Sized + Serialize>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>;
 
     /// Finishes serializing a struct.
     fn end(self) -> Result<Self::Ok, Self::Error>;
@@ -410,7 +410,7 @@ pub trait SerializeStructVariant {
     type Error: Error;
 
     /// Serialize a struct variant element.
-    fn serialize_field<V: Serialize>(&mut self, key: &'static str, value: V) -> Result<(), Self::Error>;
+    fn serialize_field<T: ?Sized + Serialize>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>;
 
     /// Finishes serializing a struct variant.
     fn end(self) -> Result<Self::Ok, Self::Error>;
diff --git a/serde_codegen/src/ser.rs b/serde_codegen/src/ser.rs
index ae3a6c7f..c8efe1af 100644
--- a/serde_codegen/src/ser.rs
+++ b/serde_codegen/src/ser.rs
@@ -548,7 +548,7 @@ fn wrap_serialize_with(
             }
         }
 
-        __SerializeWith {
+        &__SerializeWith {
             value: #value,
             phantom: ::std::marker::PhantomData::<#item_ty>,
         }
diff --git a/serde_test/src/ser.rs b/serde_test/src/ser.rs
index 60c50125..c97de428 100644
--- a/serde_test/src/ser.rs
+++ b/serde_test/src/ser.rs
@@ -139,20 +139,20 @@ impl<'s, 'a, I> ser::Serializer for &'s mut Serializer<'a, I>
         Ok(())
     }
 
-    fn serialize_newtype_struct<T>(self,
-                                   name: &'static str,
-                                   value: T) -> Result<(), Error>
+    fn serialize_newtype_struct<T: ?Sized>(self,
+                                           name: &'static str,
+                                           value: &T) -> Result<(), Error>
         where T: Serialize,
     {
         assert_eq!(self.tokens.next(), Some(&Token::StructNewType(name)));
         value.serialize(self)
     }
 
-    fn serialize_newtype_variant<T>(self,
-                                    name: &str,
-                                    _variant_index: usize,
-                                    variant: &str,
-                                    value: T) -> Result<(), Error>
+    fn serialize_newtype_variant<T: ?Sized>(self,
+                                            name: &str,
+                                            _variant_index: usize,
+                                            variant: &str,
+                                            value: &T) -> Result<(), Error>
         where T: Serialize,
     {
         assert_eq!(self.tokens.next(), Some(&Token::EnumNewType(name, variant)));
@@ -164,8 +164,8 @@ impl<'s, 'a, I> ser::Serializer for &'s mut Serializer<'a, I>
         Ok(())
     }
 
-    fn serialize_some<V>(self, value: V) -> Result<(), Error>
-        where V: Serialize,
+    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<(), Error>
+        where T: Serialize,
     {
         assert_eq!(self.tokens.next(), Some(&Token::Option(true)));
         value.serialize(self)
@@ -228,7 +228,7 @@ impl<'s, 'a, I> ser::SerializeSeq for &'s mut Serializer<'a, I>
     type Ok = ();
     type Error = Error;
 
-    fn serialize_element<T>(&mut self, value: T) -> Result<(), Error>
+    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
         where T: Serialize
     {
         assert_eq!(self.tokens.next(), Some(&Token::SeqSep));
@@ -247,7 +247,7 @@ impl<'s, 'a, I> ser::SerializeTuple for &'s mut Serializer<'a, I>
     type Ok = ();
     type Error = Error;
 
-    fn serialize_element<T>(&mut self, value: T) -> Result<(), Error>
+    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
         where T: Serialize
     {
         assert_eq!(self.tokens.next(), Some(&Token::TupleSep));
@@ -266,7 +266,7 @@ impl<'s, 'a, I> ser::SerializeTupleStruct for &'s mut Serializer<'a, I>
     type Ok = ();
     type Error = Error;
 
-    fn serialize_field<T>(&mut self, value: T) -> Result<(), Error>
+    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
         where T: Serialize
     {
         assert_eq!(self.tokens.next(), Some(&Token::TupleStructSep));
@@ -285,7 +285,7 @@ impl<'s, 'a, I> ser::SerializeTupleVariant for &'s mut Serializer<'a, I>
     type Ok = ();
     type Error = Error;
 
-    fn serialize_field<T>(&mut self, value: T) -> Result<(), Error>
+    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
         where T: Serialize
     {
         assert_eq!(self.tokens.next(), Some(&Token::EnumSeqSep));
@@ -304,12 +304,12 @@ impl<'s, 'a, I> ser::SerializeMap for &'s mut Serializer<'a, I>
     type Ok = ();
     type Error = Error;
 
-    fn serialize_key<T>(&mut self, key: T) -> Result<(), Self::Error> where T: Serialize {
+    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error> where T: Serialize {
         assert_eq!(self.tokens.next(), Some(&Token::MapSep));
         key.serialize(&mut **self)
     }
 
-    fn serialize_value<T>(&mut self, value: T) -> Result<(), Self::Error> where T: Serialize {
+    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> where T: Serialize {
         value.serialize(&mut **self)
     }
 
@@ -325,7 +325,7 @@ impl<'s, 'a, I> ser::SerializeStruct for &'s mut Serializer<'a, I>
     type Ok = ();
     type Error = Error;
 
-    fn serialize_field<V>(&mut self, key: &'static str, value: V) -> Result<(), Self::Error> where V: Serialize {
+    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error> where T: Serialize {
         assert_eq!(self.tokens.next(), Some(&Token::StructSep));
         try!(key.serialize(&mut **self));
         value.serialize(&mut **self)
@@ -343,7 +343,7 @@ impl<'s, 'a, I> ser::SerializeStructVariant for &'s mut Serializer<'a, I>
     type Ok = ();
     type Error = Error;
 
-    fn serialize_field<V>(&mut self, key: &'static str, value: V) -> Result<(), Self::Error> where V: Serialize {
+    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error> where T: Serialize {
         assert_eq!(self.tokens.next(), Some(&Token::EnumMapSep));
         try!(key.serialize(&mut **self));
         value.serialize(&mut **self)