1 files changed, 24 insertions, 136 deletions

diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
index 6ee360e3e13..3b041adc030 100644
--- a/src/libcore/vec.rs
+++ b/src/libcore/vec.rs
@@ -76,12 +76,9 @@ export zip, zip_slice;
 export swap;
 export reverse;
 export reversed;
-export iter, iter_between, each, eachi, reach, reachi;
+export each, eachi, reach, reachi;
 export each_ref, each_mut_ref, each_const_ref;
 export iter2;
-export iteri;
-export riter;
-export riteri;
 export permute;
 export windowed;
 export as_imm_buf;
@@ -857,8 +854,8 @@ 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, U) -> T) -> T {
     let mut accum = z;
-    do iter(v) |elt| {
-        accum = p(accum, elt);
+    for each_ref(v) |elt| {
+        accum = p(accum, *elt);
     }
     return accum;
 }
@@ -866,7 +863,7 @@ pure fn foldl<T: Copy, U>(z: T, v: &[U], p: fn(T, U) -> T) -> T {
 /// Reduce a vector from right to left
 pure fn foldr<T, U: Copy>(v: &[T], z: U, p: fn(T, U) -> U) -> U {
     let mut accum = z;
-    do riter(v) |elt| {
+    for reach(v) |elt| {
         accum = p(elt, accum);
     }
     return accum;
@@ -1150,7 +1147,6 @@ fn reverse<T>(v: &[mut T]) {
     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] {
     let mut rs: ~[T] = ~[];
@@ -1164,43 +1160,6 @@ pure fn reversed<T: Copy>(v: &[const T]) -> ~[T] {
 }
 
 /**
- * Iterates over a slice
- *
- * Iterates over slice `v` and, for each element, calls function `f` with the
- * element's value.
- */
-#[inline(always)]
-pure fn iter<T>(v: &[T], f: fn(T)) {
-    iter_between(v, 0u, vec::len(v), f)
-}
-
-/*
-Function: iter_between
-
-Iterates over a slice
-
-Iterates over slice `v` and, for each element, calls function `f` with the
-element's value.
-
-*/
-#[inline(always)]
-pure fn iter_between<T>(v: &[T], start: uint, end: uint, f: fn(T)) {
-    do as_imm_buf(v) |base_ptr, len| {
-        assert start <= end;
-        assert end <= len;
-        unsafe {
-            let mut n = end;
-            let mut p = ptr::offset(base_ptr, start);
-            while n > start {
-                f(*p);
-                p = ptr::offset(p, 1u);
-                n -= 1u;
-            }
-        }
-    }
-}
-
-/**
  * Iterates over a vector, with option to break
  *
  * Return true to continue, false to break.
@@ -1345,43 +1304,6 @@ fn iter2<U, T>(v1: &[U], v2: &[T], f: fn(U, T)) {
 }
 
 /**
- * Iterates over a vector's elements and indexes
- *
- * Iterates over vector `v` and, for each element, calls function `f` with the
- * element's value and index.
- */
-#[inline(always)]
-pure fn iteri<T>(v: &[T], f: fn(uint, T)) {
-    let mut i = 0u;
-    let l = len(v);
-    while i < l { f(i, v[i]); i += 1u; }
-}
-
-/**
- * Iterates over a vector in reverse
- *
- * Iterates over vector `v` and, for each element, calls function `f` with the
- * element's value.
- */
-pure fn riter<T>(v: &[T], f: fn(T)) {
-    riteri(v, |_i, v| f(v))
-}
-
-/**
- * Iterates over a vector's elements and indexes in reverse
- *
- * Iterates over vector `v` and, for each element, calls function `f` with the
- * element's value and index.
- */
-pure fn riteri<T>(v: &[T], f: fn(uint, T)) {
-    let mut i = len(v);
-    while 0u < i {
-        i -= 1u;
-        f(i, v[i]);
-    };
-}
-
-/**
  * Iterate over all permutations of vector `v`.
  *
  * Permutations are produced in lexicographic order with respect to the order
@@ -1414,12 +1336,12 @@ pure fn permute<T: Copy>(v: &[const T], put: fn(~[T])) {
 pure fn windowed<TT: Copy>(nn: uint, xx: &[TT]) -> ~[~[TT]] {
     let mut ww = ~[];
     assert 1u <= nn;
-    vec::iteri (xx, |ii, _x| {
+    for vec::eachi (xx) |ii, _x| {
         let len = vec::len(xx);
         if ii+nn <= len unsafe {
             vec::push(ww, vec::slice(xx, ii, ii+nn));
         }
-    });
+    }
     move ww
 }
 
@@ -1626,10 +1548,6 @@ impl<T: Copy> &[const T]: CopyableVector<T> {
 
 trait ImmutableVector<T> {
     pure fn foldr<U: Copy>(z: U, p: fn(T, U) -> U) -> U;
-    pure fn iter(f: fn(T));
-    pure fn iteri(f: fn(uint, T));
-    pure fn riter(f: fn(T));
-    pure fn riteri(f: fn(uint, T));
     pure fn map<U>(f: fn(T) -> U) -> ~[U];
     pure fn mapi<U>(f: fn(uint, T) -> U) -> ~[U];
     fn map_r<U>(f: fn(x: &T) -> U) -> ~[U];
@@ -1650,38 +1568,6 @@ impl<T> &[T]: ImmutableVector<T> {
     /// Reduce a vector from right to left
     #[inline]
     pure fn foldr<U: Copy>(z: U, p: fn(T, U) -> U) -> U { foldr(self, z, p) }
-    /**
-     * Iterates over a vector
-     *
-     * Iterates over vector `v` and, for each element, calls function `f` with
-     * the element's value.
-     */
-    #[inline]
-    pure fn iter(f: fn(T)) { iter(self, f) }
-    /**
-     * Iterates over a vector's elements and indexes
-     *
-     * Iterates over vector `v` and, for each element, calls function `f` with
-     * the element's value and index.
-     */
-    #[inline]
-    pure fn iteri(f: fn(uint, T)) { iteri(self, f) }
-    /**
-     * Iterates over a vector in reverse
-     *
-     * Iterates over vector `v` and, for each element, calls function `f` with
-     * the element's value.
-     */
-    #[inline]
-    pure fn riter(f: fn(T)) { riter(self, f) }
-    /**
-     * Iterates over a vector's elements and indexes in reverse
-     *
-     * Iterates over vector `v` and, for each element, calls function `f` with
-     * the element's value and index.
-     */
-    #[inline]
-    pure fn riteri(f: fn(uint, T)) { riteri(self, f) }
     /// Apply a function to each element of a vector and return the results
     #[inline]
     pure fn map<U>(f: fn(T) -> U) -> ~[U] { map(self, f) }
@@ -2465,55 +2351,57 @@ mod tests {
     }
 
     #[test]
-    fn test_iter_empty() {
-        let mut i = 0;
-        iter::<int>(~[], |_v| i += 1);
-        assert i == 0;
+    fn test_each_empty() {
+        for each_ref::<int>(~[]) |_v| {
+            fail; // should never be executed
+        }
     }
 
     #[test]
     fn test_iter_nonempty() {
         let mut i = 0;
-        iter(~[1, 2, 3], |v| i += v);
+        for each_ref(~[1, 2, 3]) |v| {
+            i += *v;
+        }
         assert i == 6;
     }
 
     #[test]
     fn test_iteri() {
         let mut i = 0;
-        iteri(~[1, 2, 3], |j, v| {
+        for eachi(~[1, 2, 3]) |j, v| {
             if i == 0 { assert v == 1; }
             assert j + 1u == v as uint;
             i += v;
-        });
+        }
         assert i == 6;
     }
 
     #[test]
-    fn test_riter_empty() {
-        let mut i = 0;
-        riter::<int>(~[], |_v| i += 1);
-        assert i == 0;
+    fn test_reach_empty() {
+        for reach::<int>(~[]) |_v| {
+            fail; // should never execute
+        }
     }
 
     #[test]
     fn test_riter_nonempty() {
         let mut i = 0;
-        riter(~[1, 2, 3], |v| {
+        for reach(~[1, 2, 3]) |v| {
             if i == 0 { assert v == 3; }
             i += v
-        });
+        }
         assert i == 6;
     }
 
     #[test]
-    fn test_riteri() {
+    fn test_reachi() {
         let mut i = 0;
-        riteri(~[0, 1, 2], |j, v| {
+        for reachi(~[0, 1, 2]) |j, v| {
             if i == 0 { assert v == 2; }
             assert j == v as uint;
             i += v;
-        });
+        }
         assert i == 3;
     }