4 files changed, 17 insertions, 22 deletions
diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs
index dedb295dacb..c3630e9f857 100644
--- a/src/libcore/cmp.rs
+++ b/src/libcore/cmp.rs
@@ -17,8 +17,6 @@ and `Eq` to overload the `==` and `!=` operators.
 pub use nounittest::*;
 pub use unittest::*;
 
-export Ord, Eq;
-
 /// Interfaces used for comparison.
 
 // Awful hack to work around duplicate lang items in core test.
diff --git a/src/libcore/core.rc b/src/libcore/core.rc
index ea2645107cf..146ce946e60 100644
--- a/src/libcore/core.rc
+++ b/src/libcore/core.rc
@@ -206,11 +206,8 @@ mod uniq;
 // Ubiquitous-utility-type modules
 
 #[cfg(notest)]
-#[legacy_exports]
 mod ops;
-#[legacy_exports]
 mod cmp;
-#[legacy_exports]
 mod num;
 #[legacy_exports]
 mod hash;
diff --git a/src/libcore/num.rs b/src/libcore/num.rs
index 585a72d70ae..d84f97c9639 100644
--- a/src/libcore/num.rs
+++ b/src/libcore/num.rs
@@ -1,6 +1,6 @@
 //! An interface for numeric types
 
-trait Num {
+pub trait Num {
     // FIXME: Trait composition. (#2616)
     pure fn add(other: &self) -> self;
     pure fn sub(other: &self) -> self;
diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs
index 70005020762..994e010e452 100644
--- a/src/libcore/ops.rs
+++ b/src/libcore/ops.rs
@@ -1,82 +1,82 @@
 // Core operators and kinds.
 
 #[lang="const"]
-trait Const {
+pub trait Const {
     // Empty.
 }
 
 #[lang="copy"]
-trait Copy {
+pub trait Copy {
     // Empty.
 }
 
 #[lang="send"]
-trait Send {
+pub trait Send {
     // Empty.
 }
 
 #[lang="owned"]
-trait Owned {
+pub trait Owned {
     // Empty.
 }
 
 #[lang="add"]
-trait Add<RHS,Result> {
+pub trait Add<RHS,Result> {
     pure fn add(rhs: &RHS) -> Result;
 }
 
 #[lang="sub"]
-trait Sub<RHS,Result> {
+pub trait Sub<RHS,Result> {
     pure fn sub(rhs: &RHS) -> Result;
 }
 
 #[lang="mul"]
-trait Mul<RHS,Result> {
+pub trait Mul<RHS,Result> {
     pure fn mul(rhs: &RHS) -> Result;
 }
 
 #[lang="div"]
-trait Div<RHS,Result> {
+pub trait Div<RHS,Result> {
     pure fn div(rhs: &RHS) -> Result;
 }
 
 #[lang="modulo"]
-trait Modulo<RHS,Result> {
+pub trait Modulo<RHS,Result> {
     pure fn modulo(rhs: &RHS) -> Result;
 }
 
 #[lang="neg"]
-trait Neg<Result> {
+pub trait Neg<Result> {
     pure fn neg() -> Result;
 }
 
 #[lang="bitand"]
-trait BitAnd<RHS,Result> {
+pub trait BitAnd<RHS,Result> {
     pure fn bitand(rhs: &RHS) -> Result;
 }
 
 #[lang="bitor"]
-trait BitOr<RHS,Result> {
+pub trait BitOr<RHS,Result> {
     pure fn bitor(rhs: &RHS) -> Result;
 }
 
 #[lang="bitxor"]
-trait BitXor<RHS,Result> {
+pub trait BitXor<RHS,Result> {
     pure fn bitxor(rhs: &RHS) -> Result;
 }
 
 #[lang="shl"]
-trait Shl<RHS,Result> {
+pub trait Shl<RHS,Result> {
     pure fn shl(rhs: &RHS) -> Result;
 }
 
 #[lang="shr"]
-trait Shr<RHS,Result> {
+pub trait Shr<RHS,Result> {
     pure fn shr(rhs: &RHS) -> Result;
 }
 
 #[lang="index"]
-trait Index<Index,Result> {
+pub trait Index<Index,Result> {
     pure fn index(+index: Index) -> Result;
 }