diff --git a/benches/client.rs b/benches/client.rs
index c8a88639..69179c00 100644
--- a/benches/client.rs
+++ b/benches/client.rs
@@ -4,7 +4,7 @@ extern crate hyper;
 
 extern crate test;
 
-use std::fmt::{mod, Show};
+use std::fmt::{self, Show};
 use std::io::net::ip::Ipv4Addr;
 use hyper::server::{Request, Response, Server};
 use hyper::header::Headers;
diff --git a/benches/client_mock_tcp.rs b/benches/client_mock_tcp.rs
index 599206ec..3776077c 100644
--- a/benches/client_mock_tcp.rs
+++ b/benches/client_mock_tcp.rs
@@ -4,7 +4,7 @@ extern crate hyper;
 
 extern crate test;
 
-use std::fmt::{mod, Show};
+use std::fmt::{self, Show};
 use std::str::from_str;
 use std::io::{IoResult, MemReader};
 use std::io::net::ip::SocketAddr;
diff --git a/src/client/request.rs b/src/client/request.rs
index 6787e86b..e83ed7c5 100644
--- a/src/client/request.rs
+++ b/src/client/request.rs
@@ -6,7 +6,7 @@ use url::Url;
 use method;
 use method::Method::{Get, Post, Delete, Put, Patch, Head, Options};
 use header::Headers;
-use header::common::{mod, Host};
+use header::common::{self, Host};
 use net::{NetworkStream, NetworkConnector, HttpConnector, Fresh, Streaming};
 use http::{HttpWriter, LINE_ENDING};
 use http::HttpWriter::{ThroughWriter, ChunkedWriter, SizedWriter, EmptyWriter};
diff --git a/src/header/common/accept_encoding.rs b/src/header/common/accept_encoding.rs
index 622de977..5f86794e 100644
--- a/src/header/common/accept_encoding.rs
+++ b/src/header/common/accept_encoding.rs
@@ -7,7 +7,7 @@ use header::shared;
 ///
 /// The `Accept-Encoding` header can be used by clients to indicate what
 /// response encodings they accept.
-#[deriving(Clone, PartialEq, Show)]
+#[derive(Clone, PartialEq, Show)]
 pub struct AcceptEncoding(pub Vec<shared::QualityItem<shared::Encoding>>);
 
 deref!(AcceptEncoding -> Vec<shared::QualityItem<shared::Encoding>>);
diff --git a/src/header/common/allow.rs b/src/header/common/allow.rs
index dcd4bc28..b49d29d6 100644
--- a/src/header/common/allow.rs
+++ b/src/header/common/allow.rs
@@ -1,6 +1,6 @@
 use header::{Header, HeaderFormat};
 use method::Method;
-use std::fmt::{mod};
+use std::fmt::{self};
 use header::shared::util::{from_comma_delimited, fmt_comma_delimited};
 
 /// The `Allow` header.
@@ -31,7 +31,7 @@ impl HeaderFormat for Allow {
 mod tests {
     use super::Allow;
     use header::Header;
-    use method::Method::{mod, Options, Get, Put, Post, Delete, Head, Trace, Connect, Patch, Extension};
+    use method::Method::{self, Options, Get, Put, Post, Delete, Head, Trace, Connect, Patch, Extension};
 
     #[test]
     fn test_allow() {
diff --git a/src/header/common/authorization.rs b/src/header/common/authorization.rs
index d6daa17e..7a8df60c 100644
--- a/src/header/common/authorization.rs
+++ b/src/header/common/authorization.rs
@@ -1,5 +1,6 @@
-use std::fmt::{mod, Show};
+use std::fmt::{self, Show};
 use std::str::{FromStr, from_utf8};
+use std::ops::{Deref, DerefMut};
 use serialize::base64::{ToBase64, FromBase64, Standard, Config, Newline};
 use header::{Header, HeaderFormat};
 
@@ -7,13 +8,15 @@ use header::{Header, HeaderFormat};
 #[derive(Clone, PartialEq, Show)]
 pub struct Authorization<S: Scheme>(pub S);
 
-impl<S: Scheme> Deref<S> for Authorization<S> {
+impl<S: Scheme> Deref for Authorization<S> {
+    type Target = S;
+
     fn deref<'a>(&'a self) -> &'a S {
         &self.0
     }
 }
 
-impl<S: Scheme> DerefMut<S> for Authorization<S> {
+impl<S: Scheme> DerefMut for Authorization<S> {
     fn deref_mut<'a>(&'a mut self) -> &'a mut S {
         &mut self.0
     }
diff --git a/src/header/common/connection.rs b/src/header/common/connection.rs
index 1c29f47f..daed4bf3 100644
--- a/src/header/common/connection.rs
+++ b/src/header/common/connection.rs
@@ -1,5 +1,5 @@
 use header::{Header, HeaderFormat};
-use std::fmt::{mod, Show};
+use std::fmt::{self, Show};
 use std::str::FromStr;
 use header::shared::util::{from_comma_delimited, fmt_comma_delimited};
 
diff --git a/src/header/common/content_length.rs b/src/header/common/content_length.rs
index cd73bae2..13bb9f41 100644
--- a/src/header/common/content_length.rs
+++ b/src/header/common/content_length.rs
@@ -1,4 +1,4 @@
-use std::fmt::{mod, Show};
+use std::fmt::{self, Show};
 
 use header::{Header, HeaderFormat};
 use header::shared::util::from_one_raw_str;
diff --git a/src/header/common/content_type.rs b/src/header/common/content_type.rs
index fb5af41f..1ccdbe86 100644
--- a/src/header/common/content_type.rs
+++ b/src/header/common/content_type.rs
@@ -1,5 +1,5 @@
 use header::{Header, HeaderFormat};
-use std::fmt::{mod, Show};
+use std::fmt::{self, Show};
 use header::shared::util::from_one_raw_str;
 use mime::Mime;
 
diff --git a/src/header/common/cookie.rs b/src/header/common/cookie.rs
index 039f0e9a..dedb9496 100644
--- a/src/header/common/cookie.rs
+++ b/src/header/common/cookie.rs
@@ -1,5 +1,5 @@
 use header::{Header, HeaderFormat};
-use std::fmt::{mod, Show};
+use std::fmt::{self, Show};
 use std::str::from_utf8;
 
 use cookie::Cookie;
diff --git a/src/header/common/date.rs b/src/header/common/date.rs
index 9dab54b6..d7542799 100644
--- a/src/header/common/date.rs
+++ b/src/header/common/date.rs
@@ -1,4 +1,4 @@
-use std::fmt::{mod, Show};
+use std::fmt::{self, Show};
 use std::str::FromStr;
 use time::Tm;
 use header::{Header, HeaderFormat};
diff --git a/src/header/common/etag.rs b/src/header/common/etag.rs
index d6c4eebf..93164245 100644
--- a/src/header/common/etag.rs
+++ b/src/header/common/etag.rs
@@ -1,5 +1,5 @@
 use header::{Header, HeaderFormat};
-use std::fmt::{mod};
+use std::fmt::{self};
 use header::shared::util::from_one_raw_str;
 
 /// The `Etag` header.
@@ -81,7 +81,7 @@ impl Header for Etag {
 impl HeaderFormat for Etag {
     fn fmt_header(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         if self.weak {
-            try!(fmt.write(b"W/"));
+            try!(fmt.write_str("W/"));
         }
         write!(fmt, "\"{}\"", self.tag)
     }
diff --git a/src/header/common/expires.rs b/src/header/common/expires.rs
index 4933fbe0..638d928d 100644
--- a/src/header/common/expires.rs
+++ b/src/header/common/expires.rs
@@ -1,4 +1,4 @@
-use std::fmt::{mod, Show};
+use std::fmt::{self, Show};
 use std::str::FromStr;
 use time::Tm;
 use header::{Header, HeaderFormat};
diff --git a/src/header/common/host.rs b/src/header/common/host.rs
index 90759bae..a9d23602 100644
--- a/src/header/common/host.rs
+++ b/src/header/common/host.rs
@@ -1,6 +1,6 @@
 use header::{Header, HeaderFormat};
 use Port;
-use std::fmt::{mod, Show};
+use std::fmt::{self, Show};
 use header::shared::util::from_one_raw_str;
 
 /// The `Host` header.
diff --git a/src/header/common/if_modified_since.rs b/src/header/common/if_modified_since.rs
index 565c98ce..af5e9bdd 100644
--- a/src/header/common/if_modified_since.rs
+++ b/src/header/common/if_modified_since.rs
@@ -1,4 +1,4 @@
-use std::fmt::{mod, Show};
+use std::fmt::{self, Show};
 use std::str::FromStr;
 use time::Tm;
 use header::{Header, HeaderFormat};
diff --git a/src/header/common/last_modified.rs b/src/header/common/last_modified.rs
index 73a5d2c0..e9b06afa 100644
--- a/src/header/common/last_modified.rs
+++ b/src/header/common/last_modified.rs
@@ -1,4 +1,4 @@
-use std::fmt::{mod, Show};
+use std::fmt::{self, Show};
 use std::str::FromStr;
 use time::Tm;
 use header::{Header, HeaderFormat};
diff --git a/src/header/common/location.rs b/src/header/common/location.rs
index c8ee186a..ace1c777 100644
--- a/src/header/common/location.rs
+++ b/src/header/common/location.rs
@@ -1,5 +1,5 @@
 use header::{Header, HeaderFormat};
-use std::fmt::{mod, Show};
+use std::fmt::{self, Show};
 use header::shared::util::from_one_raw_str;
 
 /// The `Location` header.
diff --git a/src/header/common/mod.rs b/src/header/common/mod.rs
index f6659afa..2b1f411e 100644
--- a/src/header/common/mod.rs
+++ b/src/header/common/mod.rs
@@ -60,13 +60,15 @@ macro_rules! bench_header(
 
 macro_rules! deref(
     ($from:ty -> $to:ty) => {
-        impl Deref<$to> for $from {
+        impl ::std::ops::Deref for $from {
+            type Target = $to;
+
             fn deref<'a>(&'a self) -> &'a $to {
                 &self.0
             }
         }
 
-        impl DerefMut<$to> for $from {
+        impl ::std::ops::DerefMut for $from {
             fn deref_mut<'a>(&'a mut self) -> &'a mut $to {
                 &mut self.0
             }
diff --git a/src/header/common/server.rs b/src/header/common/server.rs
index 9e835299..4ae1a369 100644
--- a/src/header/common/server.rs
+++ b/src/header/common/server.rs
@@ -1,5 +1,5 @@
 use header::{Header, HeaderFormat};
-use std::fmt::{mod, Show};
+use std::fmt::{self, Show};
 use header::shared::util::from_one_raw_str;
 
 /// The `Server` header field.
diff --git a/src/header/common/set_cookie.rs b/src/header/common/set_cookie.rs
index 0b0a3912..57f08633 100644
--- a/src/header/common/set_cookie.rs
+++ b/src/header/common/set_cookie.rs
@@ -1,5 +1,5 @@
 use header::{Header, HeaderFormat};
-use std::fmt::{mod, Show};
+use std::fmt::{self, Show};
 use std::str::from_utf8;
 
 use cookie::Cookie;
@@ -52,7 +52,7 @@ impl HeaderFormat for SetCookie {
     fn fmt_header(&self, f: &mut fmt::Formatter) -> fmt::Result {
         for (i, cookie) in self.0.iter().enumerate() {
             if i != 0 {
-                try!(f.write(b"\r\nSet-Cookie: "));
+                try!(f.write_str("\r\nSet-Cookie: "));
             }
             try!(cookie.fmt(f));
         }
diff --git a/src/header/common/upgrade.rs b/src/header/common/upgrade.rs
index 365ddcc4..a81b374f 100644
--- a/src/header/common/upgrade.rs
+++ b/src/header/common/upgrade.rs
@@ -1,5 +1,5 @@
 use header::{Header, HeaderFormat};
-use std::fmt::{mod, Show};
+use std::fmt::{self, Show};
 use std::str::FromStr;
 use header::shared::util::{from_comma_delimited, fmt_comma_delimited};
 
diff --git a/src/header/common/user_agent.rs b/src/header/common/user_agent.rs
index d0d80999..2d477ddb 100644
--- a/src/header/common/user_agent.rs
+++ b/src/header/common/user_agent.rs
@@ -1,5 +1,5 @@
 use header::{Header, HeaderFormat};
-use std::fmt::{mod, Show};
+use std::fmt::{self, Show};
 use header::shared::util::from_one_raw_str;
 
 /// The `User-Agent` header field.
diff --git a/src/header/common/vary.rs b/src/header/common/vary.rs
index 97497f49..dcb80186 100644
--- a/src/header/common/vary.rs
+++ b/src/header/common/vary.rs
@@ -1,5 +1,5 @@
 use header::{Header, HeaderFormat, CaseInsensitive};
-use std::fmt::{mod};
+use std::fmt::{self};
 use header::shared::util::{from_comma_delimited, fmt_comma_delimited, from_one_raw_str};
 
 /// The `Allow` header.
diff --git a/src/header/mod.rs b/src/header/mod.rs
index e6c0fe80..89e7dc42 100644
--- a/src/header/mod.rs
+++ b/src/header/mod.rs
@@ -7,18 +7,20 @@
 use std::any::Any;
 use std::ascii::AsciiExt;
 use std::borrow::Cow::{Borrowed, Owned};
-use std::fmt::{mod, Show};
+use std::fmt::{self, Show};
 use std::intrinsics::TypeId;
 use std::raw::TraitObject;
 use std::str::{SendStr, FromStr};
 use std::collections::HashMap;
 use std::collections::hash_map::{Iter, Entry};
-use std::{hash, mem};
+use std::iter::FromIterator;
+use std::borrow::IntoCow;
+use std::{hash, mem, raw};
 
 use mucell::MuCell;
-use uany::{UncheckedAnyDowncast, UncheckedAnyMutDowncast};
+use uany::{UnsafeAnyExt};
 
-use http::{mod, LineEnding};
+use http::{self, LineEnding};
 use {HttpResult};
 
 pub use self::common::*;
@@ -81,19 +83,20 @@ impl HeaderFormat {
     }
 }
 
-impl<'a> UncheckedAnyDowncast<'a> for &'a HeaderFormat {
+impl UnsafeAnyExt for HeaderFormat {
     #[inline]
-    unsafe fn downcast_ref_unchecked<T: 'static>(self) -> &'a T {
-        let to: TraitObject = mem::transmute_copy(&self);
-        mem::transmute(to.data)
+    unsafe fn downcast_ref_unchecked<T: 'static>(&self) -> &T {
+        mem::transmute(mem::transmute::<&HeaderFormat, raw::TraitObject>(self).data)
     }
-}
 
-impl<'a> UncheckedAnyMutDowncast<'a> for &'a mut HeaderFormat {
     #[inline]
-    unsafe fn downcast_mut_unchecked<T: 'static>(self) -> &'a mut T {
-        let to: TraitObject = mem::transmute_copy(&self);
-        mem::transmute(to.data)
+    unsafe fn downcast_mut_unchecked<T: 'static>(&mut self) -> &mut T {
+        mem::transmute(mem::transmute::<&mut HeaderFormat, raw::TraitObject>(self).data)
+    }
+
+    #[inline]
+    unsafe fn downcast_unchecked<T: 'static>(self: Box<HeaderFormat>) -> Box<T> {
+        mem::transmute(mem::transmute::<Box<HeaderFormat>, raw::TraitObject>(self).data)
     }
 }
 
@@ -278,7 +281,9 @@ pub struct HeadersItems<'a> {
     inner: Iter<'a, CaseInsensitive, MuCell<Item>>
 }
 
-impl<'a> Iterator<HeaderView<'a>> for HeadersItems<'a> {
+impl<'a> Iterator for HeadersItems<'a> {
+    type Item = HeaderView<'a>;
+
     fn next(&mut self) -> Option<HeaderView<'a>> {
         match self.inner.next() {
             Some((k, v)) => Some(HeaderView(k, v)),
@@ -327,7 +332,7 @@ impl<'a> fmt::Show for HeaderView<'a> {
 }
 
 impl<'a> Extend<HeaderView<'a>> for Headers {
-    fn extend<I: Iterator<HeaderView<'a>>>(&mut self, mut iter: I) {
+    fn extend<I: Iterator<Item=HeaderView<'a>>>(&mut self, mut iter: I) {
         for header in iter {
             self.data.insert((*header.0).clone(), (*header.1).clone());
         }
@@ -335,7 +340,7 @@ impl<'a> Extend<HeaderView<'a>> for Headers {
 }
 
 impl<'a> FromIterator<HeaderView<'a>> for Headers {
-    fn from_iter<I: Iterator<HeaderView<'a>>>(iter: I) -> Headers {
+    fn from_iter<I: Iterator<Item=HeaderView<'a>>>(iter: I) -> Headers {
         let mut headers = Headers::new();
         headers.extend(iter);
         headers
diff --git a/src/header/shared/encoding.rs b/src/header/shared/encoding.rs
index f05d79f1..67e91cd1 100644
--- a/src/header/shared/encoding.rs
+++ b/src/header/shared/encoding.rs
@@ -7,7 +7,7 @@ pub use self::Encoding::{Chunked, Gzip, Deflate, Compress, Identity, EncodingExt
 
 /// A value to represent an encoding used in `Transfer-Encoding`
 /// or `Accept-Encoding` header.
-#[deriving(Clone, PartialEq)]
+#[derive(Clone, PartialEq)]
 pub enum Encoding {
     /// The `chunked` encoding.
     Chunked,
diff --git a/src/header/shared/quality_item.rs b/src/header/shared/quality_item.rs
index a58f4737..5272faac 100644
--- a/src/header/shared/quality_item.rs
+++ b/src/header/shared/quality_item.rs
@@ -9,7 +9,7 @@ use std::str;
 
 /// Represents an item with a quality value as defined in
 /// [RFC7231](https://tools.ietf.org/html/rfc7231#section-5.3.1).
-#[deriving(Clone, PartialEq)]
+#[derive(Clone, PartialEq)]
 pub struct QualityItem<T> {
     /// The actual contents of the field.
     pub item: T,
diff --git a/src/http.rs b/src/http.rs
index 074bb021..610303ec 100644
--- a/src/http.rs
+++ b/src/http.rs
@@ -1,10 +1,11 @@
 //! Pieces pertaining to the HTTP message protocol.
 use std::borrow::Cow::{Borrowed, Owned};
+use std::borrow::IntoCow;
 use std::cmp::min;
 use std::fmt;
-use std::io::{mod, Reader, IoResult, BufWriter};
+use std::io::{self, Reader, IoResult, BufWriter};
 use std::num::from_u16;
-use std::str::{mod, SendStr, FromStr};
+use std::str::{self, SendStr, FromStr};
 
 use url::Url;
 use url::ParseError as UrlError;
@@ -693,7 +694,7 @@ fn expect(r: IoResult<u8>, expected: u8) -> HttpResult<()> {
 
 #[cfg(test)]
 mod tests {
-    use std::io::{mod, MemReader, MemWriter};
+    use std::io::{self, MemReader, MemWriter};
     use std::borrow::Cow::{Borrowed, Owned};
     use test::Bencher;
     use uri::RequestUri;
diff --git a/src/lib.rs b/src/lib.rs
index 6377a631..9ad7b217 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,4 +1,6 @@
-#![feature(macro_rules, phase, default_type_params, slicing_syntax, globs)]
+#![feature(macro_rules, phase, default_type_params,
+           slicing_syntax, globs, associated_types,
+           old_orphan_check)]
 #![deny(missing_docs)]
 #![deny(warnings)]
 #![experimental]
@@ -158,21 +160,22 @@ macro_rules! todo(
     })
 );
 
-#[allow(dead_code)]
-struct Trace;
-
-impl fmt::Show for Trace {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        let _ = backtrace::write(fmt);
-        Result::Ok(())
-    }
-}
-
-macro_rules! trace(
-    ($($arg:tt)*) => (if cfg!(not(ndebug)) {
-        log!(5, "{}\n{}", format_args!($($arg)*), ::Trace)
-    })
-);
+// FIXME(reem): Uncomment this when backtrace::write can write to a fmt::Formatter.
+// #[allow(dead_code)]
+// struct Trace;
+//
+// impl fmt::Show for Trace {
+//     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+//         let _ = backtrace::write(fmt);
+//         Result::Ok(())
+//     }
+// }
+//
+// macro_rules! trace(
+//     ($($arg:tt)*) => (if cfg!(not(ndebug)) {
+//         log!(5, "{}\n{}", format_args!($($arg)*), ::Trace)
+//     })
+// );
 
 macro_rules! inspect(
     ($name:expr, $value:expr) => ({
diff --git a/src/net.rs b/src/net.rs
index 420e807d..0abeb27a 100644
--- a/src/net.rs
+++ b/src/net.rs
@@ -7,10 +7,10 @@ use std::io::{IoResult, IoError, ConnectionAborted, InvalidInput, OtherIoError,
               Stream, Listener, Acceptor};
 use std::io::net::ip::{SocketAddr, ToSocketAddr, Port};
 use std::io::net::tcp::{TcpStream, TcpListener, TcpAcceptor};
-use std::mem::{mod, transmute, transmute_copy};
-use std::raw::{mod, TraitObject};
+use std::mem::{self, transmute, transmute_copy};
+use std::raw::{self, TraitObject};
 
-use uany::UncheckedBoxAnyDowncast;
+use uany::UnsafeAnyExt;
 use openssl::ssl::{Ssl, SslStream, SslContext, VerifyCallback};
 use openssl::ssl::SslVerifyMode::SslVerifyPeer;
 use openssl::ssl::SslMethod::Sslv23;
@@ -107,12 +107,12 @@ impl<'a> Writer for &'a mut NetworkStream {
 
 impl UnsafeAnyExt for NetworkStream + Send {
     unsafe fn downcast_ref_unchecked<T: 'static>(&self) -> &T {
-        mem::transmute(mem::transmute::<&NetworkStream + Send,
+        mem::transmute(mem::transmute::<&(NetworkStream + Send),
                                         raw::TraitObject>(self).data)
     }
 
     unsafe fn downcast_mut_unchecked<T: 'static>(&mut self) -> &mut T {
-        mem::transmute(mem::transmute::<&mut NetworkStream + Send,
+        mem::transmute(mem::transmute::<&mut (NetworkStream + Send),
                                         raw::TraitObject>(self).data)
     }
 
@@ -301,7 +301,7 @@ fn lift_ssl_error(ssl: SslError) -> IoError {
 #[cfg(test)]
 mod tests {
     use std::boxed::BoxAny;
-    use uany::UncheckedBoxAnyDowncast;
+    use uany::UnsafeAnyExt;
 
     use mock::MockStream;
     use super::NetworkStream;
diff --git a/src/server/request.rs b/src/server/request.rs
index 4a7697cd..c302706e 100644
--- a/src/server/request.rs
+++ b/src/server/request.rs
@@ -7,7 +7,7 @@ use std::io::net::ip::SocketAddr;
 
 use {HttpResult};
 use version::{HttpVersion};
-use method::Method::{mod, Get, Head};
+use method::Method::{self, Get, Head};
 use header::Headers;
 use header::common::{ContentLength, TransferEncoding};
 use http::{read_request_line};
diff --git a/src/status.rs b/src/status.rs
index 4f25c584..496e82ab 100644
--- a/src/status.rs
+++ b/src/status.rs
@@ -1,7 +1,10 @@
 //! Status Codes
 use std::fmt;
+use std::num::{FromPrimitive, ToPrimitive};
 use std::mem::transmute;
 
+use std::cmp::Ordering::{self, Less, Equal, Greater};
+
 // shamelessly lifted from Teepee. I tried a few schemes, this really
 // does seem like the best.