De-export std::{base64,cmp,par}. Part of #3583.

4 files changed, 8 insertions, 12 deletions

diff --git a/src/libstd/base64.rs b/src/libstd/base64.rs
index e5eacd5c440..995910e635d 100644
--- a/src/libstd/base64.rs
+++ b/src/libstd/base64.rs
@@ -2,7 +2,7 @@
 #[forbid(deprecated_pattern)];
 use io::Reader;
 
-trait ToBase64 {
+pub trait ToBase64 {
     fn to_base64() -> ~str;
 }
 
@@ -63,7 +63,7 @@ impl &str: ToBase64 {
     }
 }
 
-trait FromBase64 {
+pub trait FromBase64 {
     fn from_base64() -> ~[u8];
 }
 
diff --git a/src/libstd/cmp.rs b/src/libstd/cmp.rs
index 9b094f9215c..52c50a39f25 100644
--- a/src/libstd/cmp.rs
+++ b/src/libstd/cmp.rs
@@ -4,7 +4,7 @@
 
 const fuzzy_epsilon: float = 1.0e-6;
 
-trait FuzzyEq {
+pub trait FuzzyEq {
     pure fn fuzzy_eq(other: &self) -> bool;
 }
 
diff --git a/src/libstd/par.rs b/src/libstd/par.rs
index 2f98c4bad34..a0c9a1b92fe 100644
--- a/src/libstd/par.rs
+++ b/src/libstd/par.rs
@@ -1,6 +1,5 @@
 use future_spawn = future::spawn;
 
-export map, mapi, alli, any, mapi_factory;
 
 /**
  * The maximum number of tasks this module will spawn for a single
@@ -73,7 +72,7 @@ fn map_slices<A: Copy Send, B: Copy Send>(
 }
 
 /// A parallel version of map.
-fn map<A: Copy Send, B: Copy Send>(xs: ~[A], f: fn~(A) -> B) -> ~[B] {
+pub fn map<A: Copy Send, B: Copy Send>(xs: ~[A], f: fn~(A) -> B) -> ~[B] {
     vec::concat(map_slices(xs, || {
         fn~(_base: uint, slice : &[A], copy f) -> ~[B] {
             vec::map(slice, |x| f(*x))
@@ -82,7 +81,7 @@ fn map<A: Copy Send, B: Copy Send>(xs: ~[A], f: fn~(A) -> B) -> ~[B] {
 }
 
 /// A parallel version of mapi.
-fn mapi<A: Copy Send, B: Copy Send>(xs: ~[A],
+pub fn mapi<A: Copy Send, B: Copy Send>(xs: ~[A],
                                     f: fn~(uint, A) -> B) -> ~[B] {
     let slices = map_slices(xs, || {
         fn~(base: uint, slice : &[A], copy f) -> ~[B] {
@@ -103,7 +102,7 @@ fn mapi<A: Copy Send, B: Copy Send>(xs: ~[A],
  * In this case, f is a function that creates functions to run over the
  * inner elements. This is to skirt the need for copy constructors.
  */
-fn mapi_factory<A: Copy Send, B: Copy Send>(
+pub fn mapi_factory<A: Copy Send, B: Copy Send>(
     xs: &[A], f: fn() -> fn~(uint, A) -> B) -> ~[B] {
     let slices = map_slices(xs, || {
         let f = f();
@@ -120,7 +119,7 @@ fn mapi_factory<A: Copy Send, B: Copy Send>(
 }
 
 /// Returns true if the function holds for all elements in the vector.
-fn alli<A: Copy Send>(xs: ~[A], f: fn~(uint, A) -> bool) -> bool {
+pub fn alli<A: Copy Send>(xs: ~[A], f: fn~(uint, A) -> bool) -> bool {
     do vec::all(map_slices(xs, || {
         fn~(base: uint, slice : &[A], copy f) -> bool {
             vec::alli(slice, |i, x| {
@@ -131,7 +130,7 @@ fn alli<A: Copy Send>(xs: ~[A], f: fn~(uint, A) -> bool) -> bool {
 }
 
 /// Returns true if the function holds for any elements in the vector.
-fn any<A: Copy Send>(xs: ~[A], f: fn~(A) -> bool) -> bool {
+pub fn any<A: Copy Send>(xs: ~[A], f: fn~(A) -> bool) -> bool {
     do vec::any(map_slices(xs, || {
         fn~(_base : uint, slice: &[A], copy f) -> bool {
             vec::any(slice, |x| f(x))
diff --git a/src/libstd/std.rc b/src/libstd/std.rc
index c3b7c1793ec..2f75ae07c84 100644
--- a/src/libstd/std.rc
+++ b/src/libstd/std.rc
@@ -132,11 +132,8 @@ mod prettyprint;
 mod prettyprint2;
 #[legacy_exports]
 mod arena;
-#[legacy_exports]
 mod par;
-#[legacy_exports]
 mod cmp;
-#[legacy_exports]
 mod base64;
 
 #[cfg(unicode)]