De-export vec. Part of #3583.

2 files changed, 139 insertions, 239 deletions

diff --git a/src/libcore/core.rc b/src/libcore/core.rc
index 3faa8eab018..da50ff77c52 100644
--- a/src/libcore/core.rc
+++ b/src/libcore/core.rc
@@ -170,7 +170,6 @@ mod f32;
 mod f64;
 mod str;
 mod ptr;
-#[legacy_exports]
 mod vec;
 mod at_vec;
 mod bool;
diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
index d01b24f5354..3fdf97cf350 100644
--- a/src/libcore/vec.rs
+++ b/src/libcore/vec.rs
@@ -9,102 +9,8 @@ use option::{Some, None};
 use ptr::addr_of;
 use libc::size_t;
 
-export append;
-export append_one;
-export consume, consume_mut;
-export init_op;
-export is_empty;
-export is_not_empty;
-export same_length;
-export reserve;
-export reserve_at_least;
-export capacity;
-export len;
-export from_fn;
-export from_elem;
-export from_slice;
-export with_capacity;
-export build, build_sized, build_sized_opt;
-export to_mut;
-export from_mut;
-export head;
-export tail;
-export tailn;
-export init;
-export last;
-export last_opt;
-export slice;
-export view, mut_view, const_view;
-export split;
-export splitn;
-export rsplit;
-export rsplitn;
-export shift;
-export unshift;
-export pop;
-export swap_remove;
-export push, push_all, push_all_move;
-export grow;
-export grow_fn;
-export grow_set;
-export truncate;
-export dedup;
-export map;
-export mapi;
-export map2;
-export map_consume;
-export flat_map;
-export filter_map;
-export filter;
-export concat;
-export connect;
-export foldl;
-export foldr;
-export any;
-export any2;
-export all;
-export alli;
-export all2;
-export contains;
-export count;
-export find;
-export find_between;
-export rfind;
-export rfind_between;
-export position_elem;
-export position;
-export position_between;
-export rposition;
-export rposition_between;
-export unzip;
-export zip, zip_slice;
-export swap;
-export reverse;
-export reversed;
-export each, each_mut, each_const, eachi, rev_each, rev_eachi;
-export each2;
-export permute;
-export windowed;
-export as_imm_buf;
-export as_mut_buf;
-export as_const_buf;
-export raw;
-export bytes;
-export extensions;
-export ConstVector;
-export CopyableVector;
-export ImmutableVector;
-export ImmutableEqVector;
-export ImmutableCopyableVector;
-export MutableVector;
-export MutableCopyableVector;
-export IterTraitExtensions;
-export vec_concat;
-export traits;
-
 #[abi = "cdecl"]
 extern mod rustrt {
-    #[legacy_exports];
     fn vec_reserve_shared(++t: *sys::TypeDesc,
                           ++v: **raw::VecRepr,
                           ++n: libc::size_t);
@@ -112,22 +18,21 @@ extern mod rustrt {
 
 #[abi = "rust-intrinsic"]
 extern mod rusti {
-    #[legacy_exports];
     fn move_val_init<T>(&dst: T, -src: T);
 }
 
 /// Returns true if a vector contains no elements
-pure fn is_empty<T>(v: &[const T]) -> bool {
+pub pure fn is_empty<T>(v: &[const T]) -> bool {
     as_const_buf(v, |_p, len| len == 0u)
 }
 
 /// Returns true if a vector contains some elements
-pure fn is_not_empty<T>(v: &[const T]) -> bool {
+pub pure fn is_not_empty<T>(v: &[const T]) -> bool {
     as_const_buf(v, |_p, len| len > 0u)
 }
 
 /// Returns true if two vectors have the same length
-pure fn same_length<T, U>(xs: &[const T], ys: &[const U]) -> bool {
+pub pure fn same_length<T, U>(xs: &[const T], ys: &[const U]) -> bool {
     len(xs) == len(ys)
 }
 
@@ -142,7 +47,7 @@ pure fn same_length<T, U>(xs: &[const T], ys: &[const U]) -> bool {
  * * v - A vector
  * * n - The number of elements to reserve space for
  */
-fn reserve<T>(+v: &mut ~[T], +n: uint) {
+pub fn reserve<T>(+v: &mut ~[T], +n: uint) {
     // Only make the (slow) call into the runtime if we have to
     if capacity(v) < n {
         unsafe {
@@ -168,13 +73,13 @@ fn reserve<T>(+v: &mut ~[T], +n: uint) {
  * * v - A vector
  * * n - The number of elements to reserve space for
  */
-fn reserve_at_least<T>(v: &mut ~[T], n: uint) {
+pub fn reserve_at_least<T>(v: &mut ~[T], n: uint) {
     reserve(v, uint::next_power_of_two(n));
 }
 
 /// Returns the number of elements the vector can hold without reallocating
 #[inline(always)]
-pure fn capacity<T>(v: &const ~[T]) -> uint {
+pub pure fn capacity<T>(v: &const ~[T]) -> uint {
     unsafe {
         let repr: **raw::VecRepr = ::cast::transmute(v);
         (**repr).unboxed.alloc / sys::size_of::<T>()
@@ -183,7 +88,7 @@ pure fn capacity<T>(v: &const ~[T]) -> uint {
 
 /// Returns the length of a vector
 #[inline(always)]
-pure fn len<T>(v: &[const T]) -> uint {
+pub pure fn len<T>(v: &[const T]) -> uint {
     as_const_buf(v, |_p, len| len)
 }
 
@@ -193,7 +98,7 @@ pure fn len<T>(v: &[const T]) -> uint {
  * Creates an immutable vector of size `n_elts` and initializes the elements
  * to the value returned by the function `op`.
  */
-pure fn from_fn<T>(n_elts: uint, op: iter::InitOp<T>) -> ~[T] {
+pub pure fn from_fn<T>(n_elts: uint, op: iter::InitOp<T>) -> ~[T] {
     unsafe {
         let mut v = with_capacity(n_elts);
         do as_mut_buf(v) |p, _len| {
@@ -214,16 +119,16 @@ pure fn from_fn<T>(n_elts: uint, op: iter::InitOp<T>) -> ~[T] {
  * Creates an immutable vector of size `n_elts` and initializes the elements
  * to the value `t`.
  */
-pure fn from_elem<T: Copy>(n_elts: uint, +t: T) -> ~[T] {
+pub pure fn from_elem<T: Copy>(n_elts: uint, +t: T) -> ~[T] {
     from_fn(n_elts, |_i| copy t)
 }
 
 /// Creates a new unique vector with the same contents as the slice
-pure fn from_slice<T: Copy>(t: &[T]) -> ~[T] {
+pub pure fn from_slice<T: Copy>(t: &[T]) -> ~[T] {
     from_fn(t.len(), |i| t[i])
 }
 
-pure fn with_capacity<T>(capacity: uint) -> ~[T] {
+pub pure fn with_capacity<T>(capacity: uint) -> ~[T] {
     let mut vec = ~[];
     unsafe { reserve(&mut vec, capacity); }
     return move vec;
@@ -242,7 +147,7 @@ pure fn with_capacity<T>(capacity: uint) -> ~[T] {
  *             onto the vector being constructed.
  */
 #[inline(always)]
-pure fn build_sized<A>(size: uint,
+pub pure fn build_sized<A>(size: uint,
                        builder: fn(push: pure fn(+v: A))) -> ~[A] {
     let mut vec = with_capacity(size);
     builder(|+x| unsafe { vec.push(move x) });
@@ -260,7 +165,7 @@ pure fn build_sized<A>(size: uint,
  *             onto the vector being constructed.
  */
 #[inline(always)]
-pure fn build<A>(builder: fn(push: pure fn(+v: A))) -> ~[A] {
+pub pure fn build<A>(builder: fn(push: pure fn(+v: A))) -> ~[A] {
     build_sized(4, builder)
 }
 
@@ -277,28 +182,28 @@ pure fn build<A>(builder: fn(push: pure fn(+v: A))) -> ~[A] {
  *             onto the vector being constructed.
  */
 #[inline(always)]
-pure fn build_sized_opt<A>(size: Option<uint>,
+pub pure fn build_sized_opt<A>(size: Option<uint>,
                            builder: fn(push: pure fn(+v: A))) -> ~[A] {
     build_sized(size.get_default(4), builder)
 }
 
 /// Produces a mut vector from an immutable vector.
-pure fn to_mut<T>(+v: ~[T]) -> ~[mut T] {
+pub pure fn to_mut<T>(+v: ~[T]) -> ~[mut T] {
     unsafe { ::cast::transmute(move v) }
 }
 
 /// Produces an immutable vector from a mut vector.
-pure fn from_mut<T>(+v: ~[mut T]) -> ~[T] {
+pub pure fn from_mut<T>(+v: ~[mut T]) -> ~[T] {
     unsafe { ::cast::transmute(move v) }
 }
 
 // Accessors
 
 /// Returns the first element of a vector
-pure fn head<T: Copy>(v: &[const T]) -> T { v[0] }
+pub pure fn head<T: Copy>(v: &[const T]) -> T { v[0] }
 
 /// Returns a vector containing all but the first element of a slice
-pure fn tail<T: Copy>(v: &[const T]) -> ~[T] {
+pub pure fn tail<T: Copy>(v: &[const T]) -> ~[T] {
     return slice(v, 1u, len(v));
 }
 
@@ -306,18 +211,18 @@ pure fn tail<T: Copy>(v: &[const T]) -> ~[T] {
  * Returns a vector containing all but the first `n` \
  * elements of a slice
  */
-pure fn tailn<T: Copy>(v: &[const T], n: uint) -> ~[T] {
+pub pure fn tailn<T: Copy>(v: &[const T], n: uint) -> ~[T] {
     slice(v, n, len(v))
 }
 
 /// Returns a vector containing all but the last element of a slice
-pure fn init<T: Copy>(v: &[const T]) -> ~[T] {
+pub pure fn init<T: Copy>(v: &[const T]) -> ~[T] {
     assert len(v) != 0u;
     slice(v, 0u, len(v) - 1u)
 }
 
 /// Returns the last element of the slice `v`, failing if the slice is empty.
-pure fn last<T: Copy>(v: &[const T]) -> T {
+pub pure fn last<T: Copy>(v: &[const T]) -> T {
     if len(v) == 0u { fail ~"last_unsafe: empty vector" }
     v[len(v) - 1u]
 }
@@ -326,13 +231,13 @@ pure fn last<T: Copy>(v: &[const T]) -> T {
  * Returns `Some(x)` where `x` is the last element of the slice `v`,
  * or `none` if the vector is empty.
  */
-pure fn last_opt<T: Copy>(v: &[const T]) -> Option<T> {
+pub pure fn last_opt<T: Copy>(v: &[const T]) -> Option<T> {
     if len(v) == 0u { return None; }
     Some(v[len(v) - 1u])
 }
 
 /// Returns a copy of the elements from [`start`..`end`) from `v`.
-pure fn slice<T: Copy>(v: &[const T], start: uint, end: uint) -> ~[T] {
+pub pure fn slice<T: Copy>(v: &[const T], start: uint, end: uint) -> ~[T] {
     assert (start <= end);
     assert (end <= len(v));
     let mut result = ~[];
@@ -343,7 +248,7 @@ pure fn slice<T: Copy>(v: &[const T], start: uint, end: uint) -> ~[T] {
 }
 
 /// Return a slice that points into another slice.
-pure fn view<T>(v: &r/[T], start: uint, end: uint) -> &r/[T] {
+pub pure fn view<T>(v: &r/[T], start: uint, end: uint) -> &r/[T] {
     assert (start <= end);
     assert (end <= len(v));
     do as_imm_buf(v) |p, _len| {
@@ -356,7 +261,7 @@ pure fn view<T>(v: &r/[T], start: uint, end: uint) -> &r/[T] {
 }
 
 /// Return a slice that points into another slice.
-pure fn mut_view<T>(v: &r/[mut T], start: uint, end: uint) -> &r/[mut T] {
+pub pure fn mut_view<T>(v: &r/[mut T], start: uint, end: uint) -> &r/[mut T] {
     assert (start <= end);
     assert (end <= len(v));
     do as_mut_buf(v) |p, _len| {
@@ -369,7 +274,7 @@ pure fn mut_view<T>(v: &r/[mut T], start: uint, end: uint) -> &r/[mut T] {
 }
 
 /// Return a slice that points into another slice.
-pure fn const_view<T>(v: &r/[const T], start: uint,
+pub pure fn const_view<T>(v: &r/[const T], start: uint,
                       end: uint) -> &r/[const T] {
     assert (start <= end);
     assert (end <= len(v));
@@ -383,7 +288,7 @@ pure fn const_view<T>(v: &r/[const T], start: uint,
 }
 
 /// Split the vector `v` by applying each element against the predicate `f`.
-fn split<T: Copy>(v: &[T], f: fn(t: &T) -> bool) -> ~[~[T]] {
+pub fn split<T: Copy>(v: &[T], f: fn(t: &T) -> bool) -> ~[~[T]] {
     let ln = len(v);
     if (ln == 0u) { return ~[] }
 
@@ -406,7 +311,7 @@ fn split<T: Copy>(v: &[T], f: fn(t: &T) -> bool) -> ~[~[T]] {
  * Split the vector `v` by applying each element against the predicate `f` up
  * to `n` times.
  */
-fn splitn<T: Copy>(v: &[T], n: uint, f: fn(t: &T) -> bool) -> ~[~[T]] {
+pub fn splitn<T: Copy>(v: &[T], n: uint, f: fn(t: &T) -> bool) -> ~[~[T]] {
     let ln = len(v);
     if (ln == 0u) { return ~[] }
 
@@ -432,7 +337,7 @@ fn splitn<T: Copy>(v: &[T], n: uint, f: fn(t: &T) -> bool) -> ~[~[T]] {
  * Reverse split the vector `v` by applying each element against the predicate
  * `f`.
  */
-fn rsplit<T: Copy>(v: &[T], f: fn(t: &T) -> bool) -> ~[~[T]] {
+pub fn rsplit<T: Copy>(v: &[T], f: fn(t: &T) -> bool) -> ~[~[T]] {
     let ln = len(v);
     if (ln == 0u) { return ~[] }
 
@@ -456,7 +361,7 @@ fn rsplit<T: Copy>(v: &[T], f: fn(t: &T) -> bool) -> ~[~[T]] {
  * Reverse split the vector `v` by applying each element against the predicate
  * `f` up to `n times.
  */
-fn rsplitn<T: Copy>(v: &[T], n: uint, f: fn(t: &T) -> bool) -> ~[~[T]] {
+pub fn rsplitn<T: Copy>(v: &[T], n: uint, f: fn(t: &T) -> bool) -> ~[~[T]] {
     let ln = len(v);
     if (ln == 0u) { return ~[] }
 
@@ -482,7 +387,7 @@ fn rsplitn<T: Copy>(v: &[T], n: uint, f: fn(t: &T) -> bool) -> ~[~[T]] {
 // Mutators
 
 /// Removes the first element from a vector and return it
-fn shift<T>(v: &mut ~[T]) -> T {
+pub fn shift<T>(v: &mut ~[T]) -> T {
     let ln = v.len();
     assert (ln > 0);
 
@@ -507,13 +412,13 @@ fn shift<T>(v: &mut ~[T]) -> T {
 }
 
 /// Prepend an element to the vector
-fn unshift<T>(v: &mut ~[T], +x: T) {
+pub fn unshift<T>(v: &mut ~[T], +x: T) {
     let mut vv = ~[move x];
     *v <-> vv;
     v.push_all_move(vv);
 }
 
-fn consume<T>(+v: ~[T], f: fn(uint, +v: T)) unsafe {
+pub fn consume<T>(+v: ~[T], f: fn(uint, +v: T)) unsafe {
     let mut v = move v; // FIXME(#3488)
 
     do as_imm_buf(v) |p, ln| {
@@ -526,12 +431,12 @@ fn consume<T>(+v: ~[T], f: fn(uint, +v: T)) unsafe {
     raw::set_len(&mut v, 0);
 }
 
-fn consume_mut<T>(+v: ~[mut T], f: fn(uint, +v: T)) {
+pub fn consume_mut<T>(+v: ~[mut T], f: fn(uint, +v: T)) {
     consume(vec::from_mut(v), f)
 }
 
 /// Remove the last element from a vector and return it
-fn pop<T>(v: &mut ~[T]) -> T {
+pub fn pop<T>(v: &mut ~[T]) -> T {
     let ln = v.len();
     if ln == 0 {
         fail ~"sorry, cannot vec::pop an empty vector"
@@ -550,7 +455,7 @@ fn pop<T>(v: &mut ~[T]) -> T {
  *
  * Fails if index >= length.
  */
-fn swap_remove<T>(v: &mut ~[T], index: uint) -> T {
+pub fn swap_remove<T>(v: &mut ~[T], index: uint) -> T {
     let ln = v.len();
     if index >= ln {
         fail fmt!("vec::swap_remove - index %u >= length %u", index, ln);
@@ -563,7 +468,7 @@ fn swap_remove<T>(v: &mut ~[T], index: uint) -> T {
 
 /// Append an element to a vector
 #[inline(always)]
-fn push<T>(v: &mut ~[T], +initval: T) {
+pub fn push<T>(v: &mut ~[T], +initval: T) {
     unsafe {
         let repr: **raw::VecRepr = ::cast::transmute(copy v);
         let fill = (**repr).unboxed.fill;
@@ -594,7 +499,7 @@ fn push_slow<T>(+v: &mut ~[T], +initval: T) {
 }
 
 #[inline(always)]
-fn push_all<T: Copy>(+v: &mut ~[T], rhs: &[const T]) {
+pub fn push_all<T: Copy>(+v: &mut ~[T], rhs: &[const T]) {
     reserve(v, v.len() + rhs.len());
 
     for uint::range(0u, rhs.len()) |i| {
@@ -603,7 +508,7 @@ fn push_all<T: Copy>(+v: &mut ~[T], rhs: &[const T]) {
 }
 
 #[inline(always)]
-fn push_all_move<T>(v: &mut ~[T], +rhs: ~[T]) {
+pub fn push_all_move<T>(v: &mut ~[T], +rhs: ~[T]) {
     let mut rhs = move rhs; // FIXME(#3488)
     reserve(v, v.len() + rhs.len());
     unsafe {
@@ -618,7 +523,7 @@ fn push_all_move<T>(v: &mut ~[T], +rhs: ~[T]) {
 }
 
 /// Shorten a vector, dropping excess elements.
-fn truncate<T>(v: &mut ~[T], newlen: uint) {
+pub fn truncate<T>(v: &mut ~[T], newlen: uint) {
     do as_imm_buf(*v) |p, oldlen| {
         assert(newlen <= oldlen);
         unsafe {
@@ -635,7 +540,7 @@ fn truncate<T>(v: &mut ~[T], newlen: uint) {
  * Remove consecutive repeated elements from a vector; if the vector is
  * sorted, this removes all duplicates.
  */
-fn dedup<T: Eq>(v: &mut ~[T]) unsafe {
+pub fn dedup<T: Eq>(v: &mut ~[T]) unsafe {
     if v.len() < 1 { return; }
     let mut last_written = 0, next_to_read = 1;
     do as_const_buf(*v) |p, ln| {
@@ -668,7 +573,7 @@ fn dedup<T: Eq>(v: &mut ~[T]) unsafe {
 
 // Appending
 #[inline(always)]
-pure fn append<T: Copy>(+lhs: ~[T], rhs: &[const T]) -> ~[T] {
+pub pure fn append<T: Copy>(+lhs: ~[T], rhs: &[const T]) -> ~[T] {
     let mut v <- lhs;
     unsafe {
         v.push_all(rhs);
@@ -677,7 +582,7 @@ pure fn append<T: Copy>(+lhs: ~[T], rhs: &[const T]) -> ~[T] {
 }
 
 #[inline(always)]
-pure fn append_one<T>(+lhs: ~[T], +x: T) -> ~[T] {
+pub pure fn append_one<T>(+lhs: ~[T], +x: T) -> ~[T] {
     let mut v <- lhs;
     unsafe { v.push(move x); }
     move v
@@ -697,7 +602,7 @@ pure fn append_mut<T: Copy>(+lhs: ~[mut T], rhs: &[const T]) -> ~[mut T] {
  * * n - The number of elements to add
  * * initval - The value for the new elements
  */
-fn grow<T: Copy>(v: &mut ~[T], n: uint, initval: &T) {
+pub fn grow<T: Copy>(v: &mut ~[T], n: uint, initval: &T) {
     reserve_at_least(v, v.len() + n);
     let mut i: uint = 0u;
 
@@ -720,7 +625,7 @@ fn grow<T: Copy>(v: &mut ~[T], n: uint, initval: &T) {
  * * init_op - A function to call to retreive each appended element's
  *             value
  */
-fn grow_fn<T>(v: &mut ~[T], n: uint, op: iter::InitOp<T>) {
+pub fn grow_fn<T>(v: &mut ~[T], n: uint, op: iter::InitOp<T>) {
     reserve_at_least(v, v.len() + n);
     let mut i: uint = 0u;
     while i < n {
@@ -737,7 +642,7 @@ fn grow_fn<T>(v: &mut ~[T], n: uint, op: iter::InitOp<T>) {
  * of the vector, expands the vector by replicating `initval` to fill the
  * intervening space.
  */
-fn grow_set<T: Copy>(v: &mut ~[T], index: uint, initval: &T, +val: T) {
+pub fn grow_set<T: Copy>(v: &mut ~[T], index: uint, initval: &T, +val: T) {
     let l = v.len();
     if index >= l { grow(v, index - l + 1u, initval); }
     v[index] = move val;
@@ -746,7 +651,7 @@ fn grow_set<T: Copy>(v: &mut ~[T], index: uint, initval: &T, +val: T) {
 // Functional utilities
 
 /// Apply a function to each element of a vector and return the results
-pure fn map<T, U>(v: &[T], f: fn(t: &T) -> U) -> ~[U] {
+pub pure fn map<T, U>(v: &[T], f: fn(t: &T) -> U) -> ~[U] {
     let mut result = with_capacity(len(v));
     for each(v) |elem| {
         unsafe {
@@ -756,7 +661,7 @@ pure fn map<T, U>(v: &[T], f: fn(t: &T) -> U) -> ~[U] {
     move result
 }
 
-fn map_consume<T, U>(+v: ~[T], f: fn(+v: T) -> U) -> ~[U] {
+pub fn map_consume<T, U>(+v: ~[T], f: fn(+v: T) -> U) -> ~[U] {
     let mut result = ~[];
     do consume(move v) |_i, x| {
         result.push(f(move x));
@@ -765,7 +670,7 @@ fn map_consume<T, U>(+v: ~[T], f: fn(+v: T) -> U) -> ~[U] {
 }
 
 /// Apply a function to each element of a vector and return the results
-pure fn mapi<T, U>(v: &[T], f: fn(uint, t: &T) -> U) -> ~[U] {
+pub pure fn mapi<T, U>(v: &[T], f: fn(uint, t: &T) -> U) -> ~[U] {
     let mut i = 0;
     do map(v) |e| {
         i += 1;
@@ -777,14 +682,14 @@ pure fn mapi<T, U>(v: &[T], f: fn(uint, t: &T) -> U) -> ~[U] {
  * Apply a function to each element of a vector and return a concatenation
  * of each result vector
  */
-pure fn flat_map<T, U>(v: &[T], f: fn(t: &T) -> ~[U]) -> ~[U] {
+pub pure fn flat_map<T, U>(v: &[T], f: fn(t: &T) -> ~[U]) -> ~[U] {
     let mut result = ~[];
     for each(v) |elem| { unsafe{ result.push_all_move(f(elem)); } }
     move result
 }
 
 /// Apply a function to each pair of elements and return the results
-pure fn map2<T: Copy, U: Copy, V>(v0: &[T], v1: &[U],
+pub pure fn map2<T: Copy, U: Copy, V>(v0: &[T], v1: &[U],
                                   f: fn(t: &T, v: &U) -> V) -> ~[V] {
     let v0_len = len(v0);
     if v0_len != len(v1) { fail; }
@@ -803,7 +708,7 @@ pure fn map2<T: Copy, U: Copy, V>(v0: &[T], v1: &[U],
  * If function `f` returns `none` then that element is excluded from
  * the resulting vector.
  */
-pure fn filter_map<T, U: Copy>(v: &[T], f: fn(t: &T) -> Option<U>)
+pub pure fn filter_map<T, U: Copy>(v: &[T], f: fn(t: &T) -> Option<U>)
     -> ~[U] {
     let mut result = ~[];
     for each(v) |elem| {
@@ -822,7 +727,7 @@ pure fn filter_map<T, U: Copy>(v: &[T], f: fn(t: &T) -> Option<U>)
  * Apply function `f` to each element of `v` and return a vector containing
  * only those elements for which `f` returned true.
  */
-pure fn filter<T: Copy>(v: &[T], f: fn(t: &T) -> bool) -> ~[T] {
+pub pure fn filter<T: Copy>(v: &[T], f: fn(t: &T) -> bool) -> ~[T] {
     let mut result = ~[];
     for each(v) |elem| {
         if f(elem) { unsafe { result.push(*elem); } }
@@ -835,14 +740,14 @@ pure fn filter<T: Copy>(v: &[T], f: fn(t: &T) -> bool) -> ~[T] {
  *
  * Flattens a vector of vectors of T into a single vector of T.
  */
-pure fn concat<T: Copy>(v: &[~[T]]) -> ~[T] {
+pub pure fn concat<T: Copy>(v: &[~[T]]) -> ~[T] {
     let mut r = ~[];
     for each(v) |inner| { unsafe { r.push_all(*inner); } }
     move r
 }
 
 /// Concatenate a vector of vectors, placing a given separator between each
-pure fn connect<T: Copy>(v: &[~[T]], sep: &T) -> ~[T] {
+pub pure fn connect<T: Copy>(v: &[~[T]], sep: &T) -> ~[T] {
     let mut r: ~[T] = ~[];
     let mut first = true;
     for each(v) |inner| {
@@ -853,7 +758,7 @@ pure fn connect<T: Copy>(v: &[~[T]], sep: &T) -> ~[T] {
 }
 
 /// Reduce a vector from left to right
-pure fn foldl<T: Copy, U>(+z: T, v: &[U], p: fn(+t: T, u: &U) -> T) -> T {
+pub pure fn foldl<T: Copy, U>(+z: T, v: &[U], p: fn(+t: T, u: &U) -> T) -> T {
     let mut accum = z;
     for each(v) |elt| {
         // it should be possible to move accum in, but the liveness analysis
@@ -864,7 +769,7 @@ pure fn foldl<T: Copy, U>(+z: T, v: &[U], p: fn(+t: T, u: &U) -> T) -> T {
 }
 
 /// Reduce a vector from right to left
-pure fn foldr<T, U: Copy>(v: &[T], +z: U, p: fn(t: &T, +u: U) -> U) -> U {
+pub pure fn foldr<T, U: Copy>(v: &[T], +z: U, p: fn(t: &T, +u: U) -> U) -> U {
     let mut accum = z;
     for rev_each(v) |elt| {
         accum = p(elt, accum);
@@ -877,7 +782,7 @@ pure fn foldr<T, U: Copy>(v: &[T], +z: U, p: fn(t: &T, +u: U) -> U) -> U {
  *
  * If the vector contains no elements then false is returned.
  */
-pure fn any<T>(v: &[T], f: fn(t: &T) -> bool) -> bool {
+pub pure fn any<T>(v: &[T], f: fn(t: &T) -> bool) -> bool {
     for each(v) |elem| { if f(elem) { return true; } }
     return false;
 }
@@ -887,7 +792,7 @@ pure fn any<T>(v: &[T], f: fn(t: &T) -> bool) -> bool {
  *
  * If the vectors contains no elements then false is returned.
  */
-pure fn any2<T, U>(v0: &[T], v1: &[U],
+pub pure fn any2<T, U>(v0: &[T], v1: &[U],
                    f: fn(a: &T, b: &U) -> bool) -> bool {
     let v0_len = len(v0);
     let v1_len = len(v1);
@@ -904,7 +809,7 @@ pure fn any2<T, U>(v0: &[T], v1: &[U],
  *
  * If the vector contains no elements then true is returned.
  */
-pure fn all<T>(v: &[T], f: fn(t: &T) -> bool) -> bool {
+pub pure fn all<T>(v: &[T], f: fn(t: &T) -> bool) -> bool {
     for each(v) |elem| { if !f(elem) { return false; } }
     return true;
 }
@@ -914,7 +819,7 @@ pure fn all<T>(v: &[T], f: fn(t: &T) -> bool) -> bool {
  *
  * If the vector contains no elements then true is returned.
  */
-pure fn alli<T>(v: &[T], f: fn(uint, t: &T) -> bool) -> bool {
+pub pure fn alli<T>(v: &[T], f: fn(uint, t: &T) -> bool) -> bool {
     for eachi(v) |i, elem| { if !f(i, elem) { return false; } }
     return true;
 }
@@ -924,7 +829,7 @@ pure fn alli<T>(v: &[T], f: fn(uint, t: &T) -> bool) -> bool {
  *
  * If the vectors are not the same size then false is returned.
  */
-pure fn all2<T, U>(v0: &[T], v1: &[U],
+pub pure fn all2<T, U>(v0: &[T], v1: &[U],
                    f: fn(t: &T, u: &U) -> bool) -> bool {
     let v0_len = len(v0);
     if v0_len != len(v1) { return false; }
@@ -934,13 +839,13 @@ pure fn all2<T, U>(v0: &[T], v1: &[U],
 }
 
 /// Return true if a vector contains an element with the given value
-pure fn contains<T: Eq>(v: &[T], x: &T) -> bool {
+pub pure fn contains<T: Eq>(v: &[T], x: &T) -> bool {
     for each(v) |elt| { if *x == *elt { return true; } }
     return false;
 }
 
 /// Returns the number of elements that are equal to a given value
-pure fn count<T: Eq>(v: &[T], x: &T) -> uint {
+pub pure fn count<T: Eq>(v: &[T], x: &T) -> uint {
     let mut cnt = 0u;
     for each(v) |elt| { if *x == *elt { cnt += 1u; } }
     return cnt;
@@ -953,7 +858,7 @@ pure fn count<T: Eq>(v: &[T], x: &T) -> uint {
  * When function `f` returns true then an option containing the element
  * is returned. If `f` matches no elements then none is returned.
  */
-pure fn find<T: Copy>(v: &[T], f: fn(t: &T) -> bool) -> Option<T> {
+pub pure fn find<T: Copy>(v: &[T], f: fn(t: &T) -> bool) -> Option<T> {
     find_between(v, 0u, len(v), f)
 }
 
@@ -964,7 +869,7 @@ pure fn find<T: Copy>(v: &[T], f: fn(t: &T) -> bool) -> Option<T> {
  * [`start`, `end`). When function `f` returns true then an option containing
  * the element is returned. If `f` matches no elements then none is returned.
  */
-pure fn find_between<T: Copy>(v: &[T], start: uint, end: uint,
+pub pure fn find_between<T: Copy>(v: &[T], start: uint, end: uint,
                       f: fn(t: &T) -> bool) -> Option<T> {
     position_between(v, start, end, f).map(|i| v[*i])
 }
@@ -976,7 +881,7 @@ pure fn find_between<T: Copy>(v: &[T], start: uint, end: uint,
  * `f` returns true then an option containing the element is returned. If `f`
  * matches no elements then none is returned.
  */
-pure fn rfind<T: Copy>(v: &[T], f: fn(t: &T) -> bool) -> Option<T> {
+pub pure fn rfind<T: Copy>(v: &[T], f: fn(t: &T) -> bool) -> Option<T> {
     rfind_between(v, 0u, len(v), f)
 }
 
@@ -987,13 +892,13 @@ pure fn rfind<T: Copy>(v: &[T], f: fn(t: &T) -> bool) -> Option<T> {
  * [`start`, `end`). When function `f` returns true then an option containing
  * the element is returned. If `f` matches no elements then none is return.
  */
-pure fn rfind_between<T: Copy>(v: &[T], start: uint, end: uint,
+pub pure fn rfind_between<T: Copy>(v: &[T], start: uint, end: uint,
                                f: fn(t: &T) -> bool) -> Option<T> {
     rposition_between(v, start, end, f).map(|i| v[*i])
 }
 
 /// Find the first index containing a matching value
-pure fn position_elem<T: Eq>(v: &[T], x: &T) -> Option<uint> {
+pub pure fn position_elem<T: Eq>(v: &[T], x: &T) -> Option<uint> {
     position(v, |y| *x == *y)
 }
 
@@ -1004,7 +909,7 @@ pure fn position_elem<T: Eq>(v: &[T], x: &T) -> Option<uint> {
  * then an option containing the index is returned. If `f` matches no elements
  * then none is returned.
  */
-pure fn position<T>(v: &[T], f: fn(t: &T) -> bool) -> Option<uint> {
+pub pure fn position<T>(v: &[T], f: fn(t: &T) -> bool) -> Option<uint> {
     position_between(v, 0u, len(v), f)
 }
 
@@ -1015,7 +920,7 @@ pure fn position<T>(v: &[T], f: fn(t: &T) -> bool) -> Option<uint> {
  * [`start`, `end`). When function `f` returns true then an option containing
  * the index is returned. If `f` matches no elements then none is returned.
  */
-pure fn position_between<T>(v: &[T], start: uint, end: uint,
+pub pure fn position_between<T>(v: &[T], start: uint, end: uint,
                             f: fn(t: &T) -> bool) -> Option<uint> {
     assert start <= end;
     assert end <= len(v);
@@ -1036,7 +941,7 @@ pure fn rposition_elem<T: Eq>(v: &[T], x: &T) -> Option<uint> {
  * `f` returns true then an option containing the index is returned. If `f`
  * matches no elements then none is returned.
  */
-pure fn rposition<T>(v: &[T], f: fn(t: &T) -> bool) -> Option<uint> {
+pub pure fn rposition<T>(v: &[T], f: fn(t: &T) -> bool) -> Option<uint> {
     rposition_between(v, 0u, len(v), f)
 }
 
@@ -1048,7 +953,7 @@ pure fn rposition<T>(v: &[T], f: fn(t: &T) -> bool) -> Option<uint> {
  * containing the index is returned. If `f` matches no elements then none is
  * returned.
  */
-pure fn rposition_between<T>(v: &[T], start: uint, end: uint,
+pub pure fn rposition_between<T>(v: &[T], start: uint, end: uint,
                              f: fn(t: &T) -> bool) -> Option<uint> {
     assert start <= end;
     assert end <= len(v);
@@ -1087,7 +992,7 @@ pure fn unzip_slice<T: Copy, U: Copy>(v: &[(T, U)]) -> (~[T], ~[U]) {
  * and the i-th element of the second vector contains the second element
  * of the i-th tuple of the input vector.
  */
-pure fn unzip<T,U>(+v: ~[(T, U)]) -> (~[T], ~[U]) {
+pub pure fn unzip<T,U>(+v: ~[(T, U)]) -> (~[T], ~[U]) {
     let mut ts = ~[], us = ~[];
     unsafe {
         do consume(move v) |_i, p| {
@@ -1102,7 +1007,7 @@ pure fn unzip<T,U>(+v: ~[(T, U)]) -> (~[T], ~[U]) {
 /**
  * Convert two vectors to a vector of pairs, by reference. As zip().
  */
-pure fn zip_slice<T: Copy, U: Copy>(v: &[const T], u: &[const U])
+pub pure fn zip_slice<T: Copy, U: Copy>(v: &[const T], u: &[const U])
         -> ~[(T, U)] {
     let mut zipped = ~[];
     let sz = len(v);
@@ -1118,7 +1023,7 @@ pure fn zip_slice<T: Copy, U: Copy>(v: &[const T], u: &[const U])
  * Returns a vector of tuples, where the i-th tuple contains contains the
  * i-th elements from each of the input vectors.
  */
-pure fn zip<T, U>(+v: ~[T], +u: ~[U]) -> ~[(T, U)] {
+pub pure fn zip<T, U>(+v: ~[T], +u: ~[U]) -> ~[(T, U)] {
     let mut v = move v, u = move u; // FIXME(#3488)
     let mut i = len(v);
     assert i == len(u);
@@ -1140,19 +1045,19 @@ pure fn zip<T, U>(+v: ~[T], +u: ~[U]) -> ~[(T, U)] {
  * * a - The index of the first element
  * * b - The index of the second element
  */
-fn swap<T>(v: &[mut T], a: uint, b: uint) {
+pub fn swap<T>(v: &[mut T], a: uint, b: uint) {
     v[a] <-> v[b];
 }
 
 /// Reverse the order of elements in a vector, in place
-fn reverse<T>(v: &[mut T]) {
+pub fn reverse<T>(v: &[mut T]) {
     let mut i: uint = 0u;
     let ln = len::<T>(v);
     while i < ln / 2u { v[i] <-> v[ln - i - 1u]; i += 1u; }
 }
 
 /// Returns a vector with the order of elements reversed
-pure fn reversed<T: Copy>(v: &[const T]) -> ~[T] {
+pub pure fn reversed<T: Copy>(v: &[const T]) -> ~[T] {
     let mut rs: ~[T] = ~[];
     let mut i = len::<T>(v);
     if i == 0 { return (move rs); } else { i -= 1; }
@@ -1169,7 +1074,7 @@ pure fn reversed<T: Copy>(v: &[const T]) -> ~[T] {
  * Return true to continue, false to break.
  */
 #[inline(always)]
-pure fn each<T>(v: &r/[T], f: fn((&r/T)) -> bool) {
+pub pure fn each<T>(v: &r/[T], f: fn((&r/T)) -> bool) {
     //             ^^^^
     // NB---this CANNOT be &[const T]!  The reason
     // is that you are passing it to `f()` using
@@ -1193,7 +1098,7 @@ pure fn each<T>(v: &r/[T], f: fn((&r/T)) -> bool) {
 /// a vector with mutable contents and you would like
 /// to mutate the contents as you iterate.
 #[inline(always)]
-fn each_mut<T>(v: &[mut T], f: fn(elem: &mut T) -> bool) {
+pub fn each_mut<T>(v: &[mut T], f: fn(elem: &mut T) -> bool) {
     let mut i = 0;
     let n = v.len();
     while i < n {
@@ -1207,7 +1112,7 @@ fn each_mut<T>(v: &[mut T], f: fn(elem: &mut T) -> bool) {
 /// Like `each()`, but for the case where you have a vector that *may or may
 /// not* have mutable contents.
 #[inline(always)]
-pure fn each_const<T>(v: &[const T], f: fn(elem: &const T) -> bool) {
+pub pure fn each_const<T>(v: &[const T], f: fn(elem: &const T) -> bool) {
     let mut i = 0;
     let n = v.len();
     while i < n {
@@ -1224,7 +1129,7 @@ pure fn each_const<T>(v: &[const T], f: fn(elem: &const T) -> bool) {
  * Return true to continue, false to break.
  */
 #[inline(always)]
-pure fn eachi<T>(v: &r/[T], f: fn(uint, v: &r/T) -> bool) {
+pub pure fn eachi<T>(v: &r/[T], f: fn(uint, v: &r/T) -> bool) {
     let mut i = 0;
     for each(v) |p| {
         if !f(i, p) { return; }
@@ -1238,7 +1143,7 @@ pure fn eachi<T>(v: &r/[T], f: fn(uint, v: &r/T) -> bool) {
  * Return true to continue, false to break.
  */
 #[inline(always)]
-pure fn rev_each<T>(v: &r/[T], blk: fn(v: &r/T) -> bool) {
+pub pure fn rev_each<T>(v: &r/[T], blk: fn(v: &r/T) -> bool) {
     rev_eachi(v, |_i, v| blk(v))
 }
 
@@ -1248,7 +1153,7 @@ pure fn rev_each<T>(v: &r/[T], blk: fn(v: &r/T) -> bool) {
  * Return true to continue, false to break.
  */
 #[inline(always)]
-pure fn rev_eachi<T>(v: &r/[T], blk: fn(i: uint, v: &r/T) -> bool) {
+pub pure fn rev_eachi<T>(v: &r/[T], blk: fn(i: uint, v: &r/T) -> bool) {
     let mut i = v.len();
     while i > 0 {
         i -= 1;
@@ -1266,7 +1171,7 @@ pure fn rev_eachi<T>(v: &r/[T], blk: fn(i: uint, v: &r/T) -> bool) {
  * Both vectors must have the same length
  */
 #[inline]
-fn each2<U, T>(v1: &[U], v2: &[T], f: fn(u: &U, t: &T) -> bool) {
+pub fn each2<U, T>(v1: &[U], v2: &[T], f: fn(u: &U, t: &T) -> bool) {
     assert len(v1) == len(v2);
     for uint::range(0u, len(v1)) |i| {
         if !f(&v1[i], &v2[i]) {
@@ -1309,7 +1214,7 @@ pure fn each_permutation<T: Copy>(+v: &[T], put: fn(ts: &[T]) -> bool) {
     }
 }
 
-pure fn windowed<TT: Copy>(nn: uint, xx: &[TT]) -> ~[~[TT]] {
+pub pure fn windowed<TT: Copy>(nn: uint, xx: &[TT]) -> ~[~[TT]] {
     let mut ww = ~[];
     assert 1u <= nn;
     for vec::eachi (xx) |ii, _x| {
@@ -1328,8 +1233,9 @@ pure fn windowed<TT: Copy>(nn: uint, xx: &[TT]) -> ~[~[TT]] {
  * foreign interop.
  */
 #[inline(always)]
-pure fn as_imm_buf<T,U>(s: &[T], /* NB---this CANNOT be const, see below */
-                        f: fn(*T, uint) -> U) -> U {
+pub pure fn as_imm_buf<T,U>(s: &[T],
+                            /* NB---this CANNOT be const, see below */
+                            f: fn(*T, uint) -> U) -> U {
 
     // NB---Do not change the type of s to `&[const T]`.  This is
     // unsound.  The reason is that we are going to create immutable pointers
@@ -1347,7 +1253,7 @@ pure fn as_imm_buf<T,U>(s: &[T], /* NB---this CANNOT be const, see below */
 
 /// Similar to `as_imm_buf` but passing a `*const T`
 #[inline(always)]
-pure fn as_const_buf<T,U>(s: &[const T],
+pub pure fn as_const_buf<T,U>(s: &[const T],
                           f: fn(*const T, uint) -> U) -> U {
 
     unsafe {
@@ -1360,7 +1266,7 @@ pure fn as_const_buf<T,U>(s: &[const T],
 
 /// Similar to `as_imm_buf` but passing a `*mut T`
 #[inline(always)]
-pure fn as_mut_buf<T,U>(s: &[mut T],
+pub pure fn as_mut_buf<T,U>(s: &[mut T],
                         f: fn(*mut T, uint) -> U) -> U {
 
     unsafe {
@@ -1462,8 +1368,7 @@ impl<T: Ord> @[T] : Ord {
 }
 
 #[cfg(notest)]
-mod traits {
-    #[legacy_exports];
+pub mod traits {
     impl<T: Copy> ~[T] : Add<&[const T],~[T]> {
         #[inline(always)]
         pure fn add(rhs: & &[const T]) -> ~[T] {
@@ -1480,10 +1385,9 @@ mod traits {
 }
 
 #[cfg(test)]
-mod traits {
-    #[legacy_exports];}
+pub mod traits {}
 
-trait ConstVector {
+pub trait ConstVector {
     pure fn is_empty() -> bool;
     pure fn is_not_empty() -> bool;
     pure fn len() -> uint;
@@ -1502,7 +1406,7 @@ impl<T> &[const T]: ConstVector {
     pure fn len() -> uint { len(self) }
 }
 
-trait CopyableVector<T> {
+pub trait CopyableVector<T> {
     pure fn head() -> T;
     pure fn init() -> ~[T];
     pure fn last() -> T;
@@ -1529,7 +1433,7 @@ impl<T: Copy> &[const T]: CopyableVector<T> {
     pure fn tail() -> ~[T] { tail(self) }
 }
 
-trait ImmutableVector<T> {
+pub trait ImmutableVector<T> {
     pure fn view(start: uint, end: uint) -> &self/[T];
     pure fn foldr<U: Copy>(+z: U, p: fn(t: &T, +u: U) -> U) -> U;
     pure fn map<U>(f: fn(t: &T) -> U) -> ~[U];
@@ -1540,7 +1444,7 @@ trait ImmutableVector<T> {
     pure fn filter_map<U: Copy>(f: fn(t: &T) -> Option<U>) -> ~[U];
 }
 
-trait ImmutableEqVector<T: Eq> {
+pub trait ImmutableEqVector<T: Eq> {
     pure fn position(f: fn(t: &T) -> bool) -> Option<uint>;
     pure fn position_elem(t: &T) -> Option<uint>;
     pure fn rposition(f: fn(t: &T) -> bool) -> Option<uint>;
@@ -1646,7 +1550,7 @@ impl<T: Eq> &[T]: ImmutableEqVector<T> {
     }
 }
 
-trait ImmutableCopyableVector<T> {
+pub trait ImmutableCopyableVector<T> {
     pure fn filter(f: fn(t: &T) -> bool) -> ~[T];
 
     pure fn rfind(f: fn(t: &T) -> bool) -> Option<T>;
@@ -1677,7 +1581,7 @@ impl<T: Copy> &[T]: ImmutableCopyableVector<T> {
     pure fn rfind(f: fn(t: &T) -> bool) -> Option<T> { rfind(self, f) }
 }
 
-trait MutableVector<T> {
+pub trait MutableVector<T> {
     fn push(&mut self, +t: T);
     fn push_all_move(&mut self, +rhs: ~[T]);
     fn pop(&mut self) -> T;
@@ -1687,7 +1591,7 @@ trait MutableVector<T> {
     fn truncate(&mut self, newlen: uint);
 }
 
-trait MutableCopyableVector<T: Copy> {
+pub trait MutableCopyableVector<T: Copy> {
     fn push_all(&mut self, rhs: &[const T]);
     fn grow(&mut self, n: uint, initval: &T);
     fn grow_fn(&mut self, n: uint, op: iter::InitOp<T>);
@@ -1753,24 +1657,23 @@ impl<T: Eq> ~[T]: MutableEqVector<T> {
 }
 
 /// Unsafe operations
-mod raw {
-    #[legacy_exports];
+pub mod raw {
     // FIXME: This should have crate visibility (#1893 blocks that)
 
     /// The internal representation of a (boxed) vector
-    struct VecRepr {
+    pub struct VecRepr {
         box_header: box::raw::BoxHeaderRepr,
         unboxed: UnboxedVecRepr
     }
 
     /// The internal 'unboxed' representation of a vector
-    struct UnboxedVecRepr {
+    pub struct UnboxedVecRepr {
         mut fill: uint,
         mut alloc: uint,
         data: u8
     }
 
-    type SliceRepr = {
+    pub type SliceRepr = {
         mut data: *u8,
         mut len: uint
     };
@@ -1784,7 +1687,7 @@ mod raw {
      * * elts - The number of elements in the buffer
      */
     #[inline(always)]
-    unsafe fn from_buf<T>(ptr: *T, elts: uint) -> ~[T] {
+    pub unsafe fn from_buf<T>(ptr: *T, elts: uint) -> ~[T] {
         let mut dst = with_capacity(elts);
         set_len(&mut dst, elts);
         as_mut_buf(dst, |p_dst, _len_dst| ptr::memcpy(p_dst, ptr, elts));
@@ -1799,7 +1702,7 @@ mod raw {
      * the vector is actually the specified size.
      */
     #[inline(always)]
-    unsafe fn set_len<T>(v: &mut ~[T], new_len: uint) {
+    pub unsafe fn set_len<T>(v: &mut ~[T], new_len: uint) {
         let repr: **VecRepr = ::cast::transmute(v);
         (**repr).unboxed.fill = new_len * sys::size_of::<T>();
     }
@@ -1814,21 +1717,21 @@ mod raw {
      * would also make any pointers to it invalid.
      */
     #[inline(always)]
-    unsafe fn to_ptr<T>(+v: &[T]) -> *T {
+    pub unsafe fn to_ptr<T>(+v: &[T]) -> *T {
         let repr: **SliceRepr = ::cast::transmute(&v);
         return ::cast::reinterpret_cast(&addr_of(&((**repr).data)));
     }
 
     /** see `to_ptr()` */
     #[inline(always)]
-    unsafe fn to_const_ptr<T>(+v: &[const T]) -> *const T {
+    pub unsafe fn to_const_ptr<T>(+v: &[const T]) -> *const T {
         let repr: **SliceRepr = ::cast::transmute(&v);
         return ::cast::reinterpret_cast(&addr_of(&((**repr).data)));
     }
 
     /** see `to_ptr()` */
     #[inline(always)]
-    unsafe fn to_mut_ptr<T>(+v: &[mut T]) -> *mut T {
+    pub unsafe fn to_mut_ptr<T>(+v: &[mut T]) -> *mut T {
         let repr: **SliceRepr = ::cast::transmute(&v);
         return ::cast::reinterpret_cast(&addr_of(&((**repr).data)));
     }
@@ -1838,7 +1741,8 @@ mod raw {
      * not bytes).
      */
     #[inline(always)]
-    unsafe fn form_slice<T,U>(p: *T, len: uint, f: fn(v: &[T]) -> U) -> U {
+    pub unsafe fn form_slice<T,U>(p: *T, len: uint,
+                                  f: fn(v: &[T]) -> U) -> U {
         let pair = (p, len * sys::size_of::<T>());
         let v : *(&blk/[T]) =
             ::cast::reinterpret_cast(&addr_of(&pair));
@@ -1849,7 +1753,7 @@ mod raw {
      * Unchecked vector indexing.
      */
     #[inline(always)]
-    unsafe fn get<T: Copy>(v: &[const T], i: uint) -> T {
+    pub unsafe fn get<T: Copy>(v: &[const T], i: uint) -> T {
         as_const_buf(v, |p, _len| *ptr::const_offset(p, i))
     }
 
@@ -1859,7 +1763,7 @@ mod raw {
      * is newly allocated.
      */
     #[inline(always)]
-    unsafe fn init_elem<T>(v: &[mut T], i: uint, +val: T) {
+    pub unsafe fn init_elem<T>(v: &[mut T], i: uint, +val: T) {
         let mut box = Some(move val);
         do as_mut_buf(v) |p, _len| {
             let mut box2 = None;
@@ -1875,7 +1779,7 @@ mod raw {
       * Copies `count` bytes from `src` to `dst`. The source and destination
       * may overlap.
       */
-    unsafe fn memcpy<T>(dst: &[mut T], src: &[const T], count: uint) {
+    pub unsafe fn memcpy<T>(dst: &[mut T], src: &[const T], count: uint) {
         do as_mut_buf(dst) |p_dst, _len_dst| {
             do as_const_buf(src) |p_src, _len_src| {
                 ptr::memcpy(p_dst, p_src, count)
@@ -1889,7 +1793,7 @@ mod raw {
       * Copies `count` bytes from `src` to `dst`. The source and destination
       * may overlap.
       */
-    unsafe fn memmove<T>(dst: &[mut T], src: &[const T], count: uint) {
+    pub unsafe fn memmove<T>(dst: &[mut T], src: &[const T], count: uint) {
         do as_mut_buf(dst) |p_dst, _len_dst| {
             do as_const_buf(src) |p_src, _len_src| {
                 ptr::memmove(p_dst, p_src, count)
@@ -1899,14 +1803,10 @@ mod raw {
 }
 
 /// Operations on `[u8]`
-mod bytes {
-    #[legacy_exports];
-    export cmp;
-    export lt, le, eq, ne, ge, gt;
-    export memcpy, memmove;
+pub mod bytes {
 
     /// Bytewise string comparison
-    pure fn cmp(a: &~[u8], b: &~[u8]) -> int {
+    pub pure fn cmp(a: &~[u8], b: &~[u8]) -> int {
         let a_len = len(*a);
         let b_len = len(*b);
         let n = uint::min(a_len, b_len) as libc::size_t;
@@ -1927,22 +1827,22 @@ mod bytes {
     }
 
     /// Bytewise less than or equal
-    pure fn lt(a: &~[u8], b: &~[u8]) -> bool { cmp(a, b) < 0 }
+    pub pure fn lt(a: &~[u8], b: &~[u8]) -> bool { cmp(a, b) < 0 }
 
     /// Bytewise less than or equal
-    pure fn le(a: &~[u8], b: &~[u8]) -> bool { cmp(a, b) <= 0 }
+    pub pure fn le(a: &~[u8], b: &~[u8]) -> bool { cmp(a, b) <= 0 }
 
     /// Bytewise equality
-    pure fn eq(a: &~[u8], b: &~[u8]) -> bool { cmp(a, b) == 0 }
+    pub pure fn eq(a: &~[u8], b: &~[u8]) -> bool { cmp(a, b) == 0 }
 
     /// Bytewise inequality
-    pure fn ne(a: &~[u8], b: &~[u8]) -> bool { cmp(a, b) != 0 }
+    pub pure fn ne(a: &~[u8], b: &~[u8]) -> bool { cmp(a, b) != 0 }
 
     /// Bytewise greater than or equal
-    pure fn ge(a: &~[u8], b: &~[u8]) -> bool { cmp(a, b) >= 0 }
+    pub pure fn ge(a: &~[u8], b: &~[u8]) -> bool { cmp(a, b) >= 0 }
 
     /// Bytewise greater than
-    pure fn gt(a: &~[u8], b: &~[u8]) -> bool { cmp(a, b) > 0 }
+    pub pure fn gt(a: &~[u8], b: &~[u8]) -> bool { cmp(a, b) > 0 }
 
     /**
       * Copies data from one vector to another.
@@ -1950,7 +1850,7 @@ mod bytes {
       * Copies `count` bytes from `src` to `dst`. The source and destination
       * may not overlap.
       */
-    fn memcpy(dst: &[mut u8], src: &[const u8], count: uint) {
+    pub fn memcpy(dst: &[mut u8], src: &[const u8], count: uint) {
         assert dst.len() >= count;
         assert src.len() >= count;
 
@@ -1963,7 +1863,7 @@ mod bytes {
       * Copies `count` bytes from `src` to `dst`. The source and destination
       * may overlap.
       */
-    fn memmove(dst: &[mut u8], src: &[const u8], count: uint) {
+    pub fn memmove(dst: &[mut u8], src: &[const u8], count: uint) {
         assert dst.len() >= count;
         assert src.len() >= count;
 
@@ -1978,7 +1878,7 @@ mod bytes {
 // required in the slice.
 
 impl<A> &[A]: iter::BaseIter<A> {
-    pure fn each(blk: fn(v: &A) -> bool) {
+    pub pure fn each(blk: fn(v: &A) -> bool) {
         // FIXME(#2263)---should be able to call each(self, blk)
         for each(self) |e| {
             if (!blk(e)) {
@@ -1990,20 +1890,22 @@ impl<A> &[A]: iter::BaseIter<A> {
 }
 
 impl<A> &[A]: iter::ExtendedIter<A> {
-    pure fn eachi(blk: fn(uint, v: &A) -> bool) { iter::eachi(&self, blk) }
-    pure fn all(blk: fn(&A) -> bool) -> bool { iter::all(&self, blk) }
-    pure fn any(blk: fn(&A) -> bool) -> bool { iter::any(&self, blk) }
-    pure fn foldl<B>(+b0: B, blk: fn(&B, &A) -> B) -> B {
+    pub pure fn eachi(blk: fn(uint, v: &A) -> bool) {
+        iter::eachi(&self, blk)
+    }
+    pub pure fn all(blk: fn(&A) -> bool) -> bool { iter::all(&self, blk) }
+    pub pure fn any(blk: fn(&A) -> bool) -> bool { iter::any(&self, blk) }
+    pub pure fn foldl<B>(+b0: B, blk: fn(&B, &A) -> B) -> B {
         iter::foldl(&self, move b0, blk)
     }
-    pure fn position(f: fn(&A) -> bool) -> Option<uint> {
+    pub pure fn position(f: fn(&A) -> bool) -> Option<uint> {
         iter::position(&self, f)
     }
 }
 
 impl<A: Eq> &[A]: iter::EqIter<A> {
-    pure fn contains(x: &A) -> bool { iter::contains(&self, x) }
-    pure fn count(x: &A) -> uint { iter::count(&self, x) }
+    pub pure fn contains(x: &A) -> bool { iter::contains(&self, x) }
+    pub pure fn count(x: &A) -> uint { iter::count(&self, x) }
 }
 
 impl<A: Copy> &[A]: iter::CopyableIter<A> {
@@ -2020,7 +1922,9 @@ impl<A: Copy> &[A]: iter::CopyableIter<A> {
     //     iter::flat_map_to_vec(self, op)
     // }
 
-    pure fn find(p: fn(+a: A) -> bool) -> Option<A> { iter::find(&self, p) }
+    pub pure fn find(p: fn(+a: A) -> bool) -> Option<A> {
+        iter::find(&self, p)
+    }
 }
 
 impl<A: Copy Ord> &[A]: iter::CopyableOrderedIter<A> {
@@ -2031,7 +1935,6 @@ impl<A: Copy Ord> &[A]: iter::CopyableOrderedIter<A> {
 
 #[cfg(test)]
 mod tests {
-    #[legacy_exports];
 
     fn square(n: uint) -> uint { return n * n; }
 
@@ -3430,8 +3333,6 @@ mod tests {
             fail
         }
     }
-
-
 }
 
 // Local Variables: