diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs
index 867871805d05..0ad2a465522a 100644
--- a/src/libcore/cmp.rs
+++ b/src/libcore/cmp.rs
@@ -189,6 +189,81 @@ pub fn max<T: TotalOrd>(v1: T, v2: T) -> T {
     if v1 > v2 { v1 } else { v2 }
 }
 
+// Implementation of Eq/TotalEq for some primitive types
+#[cfg(not(test))]
+mod impls {
+    use cmp::{Ord, TotalOrd, Eq, TotalEq, Ordering};
+
+    // & pointers
+    impl<'a, T: Eq> Eq for &'a T {
+        #[inline]
+        fn eq(&self, other: & &'a T) -> bool { *(*self) == *(*other) }
+        #[inline]
+        fn ne(&self, other: & &'a T) -> bool { *(*self) != *(*other) }
+    }
+    impl<'a, T: Ord> Ord for &'a T {
+        #[inline]
+        fn lt(&self, other: & &'a T) -> bool { *(*self) < *(*other) }
+        #[inline]
+        fn le(&self, other: & &'a T) -> bool { *(*self) <= *(*other) }
+        #[inline]
+        fn ge(&self, other: & &'a T) -> bool { *(*self) >= *(*other) }
+        #[inline]
+        fn gt(&self, other: & &'a T) -> bool { *(*self) > *(*other) }
+    }
+    impl<'a, T: TotalOrd> TotalOrd for &'a T {
+        #[inline]
+        fn cmp(&self, other: & &'a T) -> Ordering { (**self).cmp(*other) }
+    }
+    impl<'a, T: TotalEq> TotalEq for &'a T {}
+
+    // @ pointers
+    impl<T:Eq> Eq for @T {
+        #[inline]
+        fn eq(&self, other: &@T) -> bool { *(*self) == *(*other) }
+        #[inline]
+        fn ne(&self, other: &@T) -> bool { *(*self) != *(*other) }
+    }
+    impl<T:Ord> Ord for @T {
+        #[inline]
+        fn lt(&self, other: &@T) -> bool { *(*self) < *(*other) }
+        #[inline]
+        fn le(&self, other: &@T) -> bool { *(*self) <= *(*other) }
+        #[inline]
+        fn ge(&self, other: &@T) -> bool { *(*self) >= *(*other) }
+        #[inline]
+        fn gt(&self, other: &@T) -> bool { *(*self) > *(*other) }
+    }
+    impl<T: TotalOrd> TotalOrd for @T {
+        #[inline]
+        fn cmp(&self, other: &@T) -> Ordering { (**self).cmp(*other) }
+    }
+    impl<T: TotalEq> TotalEq for @T {}
+
+    // ~ pointers
+    impl<T:Eq> Eq for ~T {
+        #[inline]
+        fn eq(&self, other: &~T) -> bool { *(*self) == *(*other) }
+        #[inline]
+        fn ne(&self, other: &~T) -> bool { *(*self) != *(*other) }
+    }
+    impl<T:Ord> Ord for ~T {
+        #[inline]
+        fn lt(&self, other: &~T) -> bool { *(*self) < *(*other) }
+        #[inline]
+        fn le(&self, other: &~T) -> bool { *(*self) <= *(*other) }
+        #[inline]
+        fn ge(&self, other: &~T) -> bool { *(*self) >= *(*other) }
+        #[inline]
+        fn gt(&self, other: &~T) -> bool { *(*self) > *(*other) }
+    }
+    impl<T: TotalOrd> TotalOrd for ~T {
+        #[inline]
+        fn cmp(&self, other: &~T) -> Ordering { (**self).cmp(*other) }
+    }
+    impl<T: TotalEq> TotalEq for ~T {}
+}
+
 #[cfg(test)]
 mod test {
     use super::lexical_ordering;
diff --git a/src/libstd/gc.rs b/src/libstd/gc.rs
index 7387eff3dfc9..9260d8d7ab2b 100644
--- a/src/libstd/gc.rs
+++ b/src/libstd/gc.rs
@@ -20,7 +20,6 @@ collector is task-local so `Gc<T>` is not sendable.
 
 use kinds::marker;
 use clone::Clone;
-use managed;
 
 /// Immutable garbage-collected pointer type
 #[lang="gc"]
@@ -55,7 +54,7 @@ impl<T: 'static> Gc<T> {
     /// Determine if two garbage-collected boxes point to the same object
     #[inline]
     pub fn ptr_eq(&self, other: &Gc<T>) -> bool {
-        managed::ptr_eq(self.ptr, other.ptr)
+        self.borrow() as *T == other.borrow() as *T
     }
 }
 
diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
index 041959f2ee72..95d67eb77d14 100644
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@@ -203,8 +203,6 @@ pub mod strbuf;
 
 pub mod ascii;
 
-mod managed;
-mod reference;
 pub mod rc;
 pub mod gc;
 
diff --git a/src/libstd/managed.rs b/src/libstd/managed.rs
deleted file mode 100644
index bf73c05440c1..000000000000
--- a/src/libstd/managed.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Operations on managed box types
-
-#[cfg(not(test))] use cmp::*;
-
-/// Determine if two shared boxes point to the same object
-#[inline]
-pub fn ptr_eq<T>(a: @T, b: @T) -> bool {
-    &*a as *T == &*b as *T
-}
-
-#[cfg(not(test))]
-impl<T:Eq> Eq for @T {
-    #[inline]
-    fn eq(&self, other: &@T) -> bool { *(*self) == *(*other) }
-    #[inline]
-    fn ne(&self, other: &@T) -> bool { *(*self) != *(*other) }
-}
-
-#[cfg(not(test))]
-impl<T:Ord> Ord for @T {
-    #[inline]
-    fn lt(&self, other: &@T) -> bool { *(*self) < *(*other) }
-    #[inline]
-    fn le(&self, other: &@T) -> bool { *(*self) <= *(*other) }
-    #[inline]
-    fn ge(&self, other: &@T) -> bool { *(*self) >= *(*other) }
-    #[inline]
-    fn gt(&self, other: &@T) -> bool { *(*self) > *(*other) }
-}
-
-#[cfg(not(test))]
-impl<T: TotalOrd> TotalOrd for @T {
-    #[inline]
-    fn cmp(&self, other: &@T) -> Ordering { (**self).cmp(*other) }
-}
-
-#[cfg(not(test))]
-impl<T: TotalEq> TotalEq for @T {}
-
-#[test]
-fn test() {
-    let x = @3;
-    let y = @3;
-    assert!((ptr_eq::<int>(x, x)));
-    assert!((ptr_eq::<int>(y, y)));
-    assert!((!ptr_eq::<int>(x, y)));
-    assert!((!ptr_eq::<int>(y, x)));
-}
diff --git a/src/libstd/owned.rs b/src/libstd/owned.rs
index 48b80e0ca8e4..4f282c5c9e9a 100644
--- a/src/libstd/owned.rs
+++ b/src/libstd/owned.rs
@@ -10,8 +10,6 @@
 
 //! Operations on unique pointer types
 
-#[cfg(not(test))] use cmp::*;
-
 /// A value that represents the global exchange heap. This is the default
 /// place that the `box` keyword allocates into when no place is supplied.
 ///
@@ -33,32 +31,3 @@ pub struct Box<T>(*T);
 
 #[cfg(test)]
 pub struct Box<T>(*T);
-
-#[cfg(not(test))]
-impl<T:Eq> Eq for Box<T> {
-    #[inline]
-    fn eq(&self, other: &Box<T>) -> bool { *(*self) == *(*other) }
-    #[inline]
-    fn ne(&self, other: &Box<T>) -> bool { *(*self) != *(*other) }
-}
-
-#[cfg(not(test))]
-impl<T:Ord> Ord for Box<T> {
-    #[inline]
-    fn lt(&self, other: &Box<T>) -> bool { *(*self) < *(*other) }
-    #[inline]
-    fn le(&self, other: &Box<T>) -> bool { *(*self) <= *(*other) }
-    #[inline]
-    fn ge(&self, other: &Box<T>) -> bool { *(*self) >= *(*other) }
-    #[inline]
-    fn gt(&self, other: &Box<T>) -> bool { *(*self) > *(*other) }
-}
-
-#[cfg(not(test))]
-impl<T: TotalOrd> TotalOrd for Box<T> {
-    #[inline]
-    fn cmp(&self, other: &Box<T>) -> Ordering { (**self).cmp(*other) }
-}
-
-#[cfg(not(test))]
-impl<T: TotalEq> TotalEq for Box<T> {}
diff --git a/src/libstd/reference.rs b/src/libstd/reference.rs
deleted file mode 100644
index eb615afd85f9..000000000000
--- a/src/libstd/reference.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Utilities for references
-
-#[cfg(not(test))]
-use cmp::{Eq, Ord, Ordering, TotalEq, TotalOrd};
-
-// Equality for region pointers
-#[cfg(not(test))]
-impl<'a, T: Eq> Eq for &'a T {
-    #[inline]
-    fn eq(&self, other: & &'a T) -> bool {
-        *(*self) == *(*other)
-    }
-    #[inline]
-    fn ne(&self, other: & &'a T) -> bool {
-        *(*self) != *(*other)
-    }
-}
-
-// Comparison for region pointers
-#[cfg(not(test))]
-impl<'a, T: Ord> Ord for &'a T {
-    #[inline]
-    fn lt(&self, other: & &'a T) -> bool {
-        *(*self) < *(*other)
-    }
-    #[inline]
-    fn le(&self, other: & &'a T) -> bool {
-        *(*self) <= *(*other)
-    }
-    #[inline]
-    fn ge(&self, other: & &'a T) -> bool {
-        *(*self) >= *(*other)
-    }
-    #[inline]
-    fn gt(&self, other: & &'a T) -> bool {
-        *(*self) > *(*other)
-    }
-}
-
-#[cfg(not(test))]
-impl<'a, T: TotalOrd> TotalOrd for &'a T {
-    #[inline]
-    fn cmp(&self, other: & &'a T) -> Ordering { (**self).cmp(*other) }
-}
-
-#[cfg(not(test))]
-impl<'a, T: TotalEq> TotalEq for &'a T {}