De-mode vec::each() and many of the str iteration routines

Note that the method foo.each() is not de-moded, nor the other
vec routines.

15 files changed, 160 insertions, 422 deletions

diff --git a/src/libcore/at_vec.rs b/src/libcore/at_vec.rs
index 069bc625623..79ee44ac49c 100644
--- a/src/libcore/at_vec.rs
+++ b/src/libcore/at_vec.rs
@@ -91,7 +91,7 @@ pure fn build_sized_opt<A>(size: Option<uint>,
 #[inline(always)]
 pure fn append<T: Copy>(lhs: @[T], rhs: &[const T]) -> @[T] {
     do build_sized(lhs.len() + rhs.len()) |push| {
-        for vec::each(lhs) |x| { push(x); }
+        for vec::each(lhs) |x| { push(*x); }
         for uint::range(0, rhs.len()) |i| { push(rhs[i]); }
     }
 }
@@ -101,7 +101,7 @@ pure fn append<T: Copy>(lhs: @[T], rhs: &[const T]) -> @[T] {
 pure fn map<T, U>(v: &[T], f: fn(T) -> U) -> @[U] {
     do build_sized(v.len()) |push| {
         for vec::each(v) |elem| {
-            push(f(elem));
+            push(f(*elem));
         }
     }
 }
diff --git a/src/libcore/cast.rs b/src/libcore/cast.rs
index 601eeff6969..1f811b0fc05 100644
--- a/src/libcore/cast.rs
+++ b/src/libcore/cast.rs
@@ -4,7 +4,7 @@ export reinterpret_cast, forget, bump_box_refcount, transmute;
 export transmute_mut, transmute_immut, transmute_region, transmute_mut_region;
 export transmute_mut_unsafe, transmute_immut_unsafe;
 
-export copy_lifetime;
+export copy_lifetime, copy_lifetime_vec;
 
 #[abi = "rust-intrinsic"]
 extern mod rusti {
@@ -85,8 +85,9 @@ unsafe fn copy_lifetime<S,T>(_ptr: &a/S, ptr: &T) -> &a/T {
 }
 
 /// Transforms lifetime of the second pointer to match the first.
-unsafe fn copy_lifetime_to_unsafe<S,T>(_ptr: &a/S, +ptr: *T) -> &a/T {
-    transmute(ptr)
+#[inline(always)]
+unsafe fn copy_lifetime_vec<S,T>(_ptr: &a/[S], ptr: &T) -> &a/T {
+    transmute_region(ptr)
 }
 
 
diff --git a/src/libcore/either.rs b/src/libcore/either.rs
index b97fd244940..9f58f46f1a0 100644
--- a/src/libcore/either.rs
+++ b/src/libcore/either.rs
@@ -34,7 +34,7 @@ fn lefts<T: Copy, U>(eithers: &[Either<T, U>]) -> ~[T] {
 
     let mut result: ~[T] = ~[];
     for vec::each(eithers) |elt| {
-        match elt {
+        match *elt {
           Left(l) => vec::push(result, l),
           _ => { /* fallthrough */ }
         }
@@ -47,7 +47,7 @@ fn rights<T, U: Copy>(eithers: &[Either<T, U>]) -> ~[U] {
 
     let mut result: ~[U] = ~[];
     for vec::each(eithers) |elt| {
-        match elt {
+        match *elt {
           Right(r) => vec::push(result, r),
           _ => { /* fallthrough */ }
         }
@@ -67,7 +67,7 @@ fn partition<T: Copy, U: Copy>(eithers: &[Either<T, U>])
     let mut lefts: ~[T] = ~[];
     let mut rights: ~[U] = ~[];
     for vec::each(eithers) |elt| {
-        match elt {
+        match *elt {
           Left(l) => vec::push(lefts, l),
           Right(r) => vec::push(rights, r)
         }
diff --git a/src/libcore/hash.rs b/src/libcore/hash.rs
index d9832036a88..7446332e261 100644
--- a/src/libcore/hash.rs
+++ b/src/libcore/hash.rs
@@ -390,7 +390,9 @@ impl &SipState : Streaming {
     fn result_str() -> ~str {
         let r = self.result_bytes();
         let mut s = ~"";
-        for vec::each(r) |b| { s += uint::to_str(b as uint, 16u); }
+        for vec::each(r) |b| {
+            s += uint::to_str(*b as uint, 16u);
+        }
         move s
     }
 
@@ -483,7 +485,9 @@ fn test_siphash() {
 
     fn to_hex_str(r:  &[u8]/8) -> ~str {
         let mut s = ~"";
-        for vec::each(*r) |b| { s += uint::to_str(b as uint, 16u); }
+        for vec::each(*r) |b| {
+            s += uint::to_str(*b as uint, 16u);
+        }
         return s;
     }
 
diff --git a/src/libcore/io.rs b/src/libcore/io.rs
index 54304658fd1..2de7da0480e 100644
--- a/src/libcore/io.rs
+++ b/src/libcore/io.rs
@@ -451,7 +451,7 @@ fn mk_file_writer(path: &Path, flags: ~[FileFlag])
 
     let mut fflags: c_int = wb();
     for vec::each(flags) |f| {
-        match f {
+        match *f {
           Append => fflags |= O_APPEND as c_int,
           Create => fflags |= O_CREAT as c_int,
           Truncate => fflags |= O_TRUNC as c_int,
diff --git a/src/libcore/iter-trait/dvec.rs b/src/libcore/iter-trait/dvec.rs
index 854e75d2838..7284d02d3ac 100644
--- a/src/libcore/iter-trait/dvec.rs
+++ b/src/libcore/iter-trait/dvec.rs
@@ -7,7 +7,12 @@ type IMPL_T<A> = dvec::DVec<A>;
  * Attempts to access this dvec during iteration will fail.
  */
 pure fn EACH<A>(self: IMPL_T<A>, f: fn(A) -> bool) {
-    unsafe { self.swap(|v| { vec::each(v, f); move v }) }
+    unsafe {
+        do self.swap |v| {
+            v.each(f);
+            move v
+        }
+    }
 }
 
 pure fn SIZE_HINT<A>(self: IMPL_T<A>) -> Option<uint> {
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index 66c5b2b234a..bce118e09af 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -300,146 +300,3 @@ pure fn copy_seq<T: Copy,IT: BaseIter<T>,BT: Buildable<T>>(
         for v.each |x| { push(x); }
     }
 }
-
-
-
-/*
-#[test]
-fn test_enumerate() {
-    enumerate(["0", "1", "2"]) {|i,j|
-        assert fmt!("%u",i) == j;
-    }
-}
-
-#[test]
-fn test_map_and_to_vec() {
-    let a = bind vec::iter(~[0, 1, 2], _);
-    let b = bind map(a, {|i| 2*i}, _);
-    let c = to_vec(b);
-    assert c == ~[0, 2, 4];
-}
-
-#[test]
-fn test_map_directly_on_vec() {
-    let b = bind map(~[0, 1, 2], {|i| 2*i}, _);
-    let c = to_vec(b);
-    assert c == ~[0, 2, 4];
-}
-
-#[test]
-fn test_filter_on_int_range() {
-    fn is_even(&&i: int) -> bool {
-        return (i % 2) == 0;
-    }
-
-    let l = to_vec(bind filter(bind int::range(0, 10, _), is_even, _));
-    assert l == ~[0, 2, 4, 6, 8];
-}
-
-#[test]
-fn test_filter_on_uint_range() {
-    fn is_even(&&i: uint) -> bool {
-        return (i % 2u) == 0u;
-    }
-
-    let l = to_vec(bind filter(bind uint::range(0u, 10u, _), is_even, _));
-    assert l == ~[0u, 2u, 4u, 6u, 8u];
-}
-
-#[test]
-fn test_filter_map() {
-    fn negativate_the_evens(&&i: int) -> Option<int> {
-        if i % 2 == 0 {
-            Some(-i)
-        } else {
-            none
-        }
-    }
-
-    let l = to_vec(bind filter_map(
-        bind int::range(0, 5, _), negativate_the_evens, _));
-    assert l == ~[0, -2, -4];
-}
-
-#[test]
-fn test_flat_map_with_option() {
-    fn if_even(&&i: int) -> Option<int> {
-        if (i % 2) == 0 { Some(i) }
-        else { none }
-    }
-
-    let a = bind vec::iter(~[0, 1, 2], _);
-    let b = bind flat_map(a, if_even, _);
-    let c = to_vec(b);
-    assert c == ~[0, 2];
-}
-
-#[test]
-fn test_flat_map_with_list() {
-    fn repeat(&&i: int) -> ~[int] {
-        let mut r = ~[];
-        int::range(0, i) {|_j| r += ~[i]; }
-        r
-    }
-
-    let a = bind vec::iter(~[0, 1, 2, 3], _);
-    let b = bind flat_map(a, repeat, _);
-    let c = to_vec(b);
-    debug!("c = %?", c);
-    assert c == ~[1, 2, 2, 3, 3, 3];
-}
-
-#[test]
-fn test_repeat() {
-    let mut c = ~[], i = 0u;
-    repeat(5u) {||
-        c += ~[(i * i)];
-        i += 1u;
-    };
-    debug!("c = %?", c);
-    assert c == ~[0u, 1u, 4u, 9u, 16u];
-}
-
-#[test]
-fn test_min() {
-    assert min(~[5, 4, 1, 2, 3]) == 1;
-}
-
-#[test]
-#[should_fail]
-#[ignore(cfg(windows))]
-fn test_min_empty() {
-    min::<int, ~[int]>(~[]);
-}
-
-#[test]
-fn test_max() {
-    assert max(~[1, 2, 4, 2, 3]) == 4;
-}
-
-#[test]
-#[should_fail]
-#[ignore(cfg(windows))]
-fn test_max_empty() {
-    max::<int, ~[int]>(~[]);
-}
-
-#[test]
-fn test_reversed() {
-    assert to_vec(bind reversed(~[1, 2, 3], _)) == ~[3, 2, 1];
-}
-
-#[test]
-fn test_count() {
-    assert count(~[1, 2, 1, 2, 1], 1) == 3u;
-}
-
-#[test]
-fn test_foldr() {
-    fn sub(&&a: int, &&b: int) -> int {
-        a - b
-    }
-    let sum = foldr(~[1, 2, 3, 4], 0, sub);
-    assert sum == -2;
-}
-*/
diff --git a/src/libcore/os.rs b/src/libcore/os.rs
index 3a15e630fc7..6c6186459ac 100644
--- a/src/libcore/os.rs
+++ b/src/libcore/os.rs
@@ -211,7 +211,7 @@ mod global_env {
         fn env() -> ~[(~str,~str)] {
             let mut pairs = ~[];
             for vec::each(rustrt::rust_env_pairs()) |p| {
-                let vs = str::splitn_char(p, '=', 1u);
+                let vs = str::splitn_char(*p, '=', 1u);
                 assert vec::len(vs) == 2u;
                 vec::push(pairs, (copy vs[0], copy vs[1]));
             }
@@ -893,7 +893,7 @@ mod tests {
         let e = env();
         assert vec::len(e) > 0u;
         for vec::each(e) |p| {
-            let (n, v) = copy p;
+            let (n, v) = copy *p;
             log(debug, n);
             let v2 = getenv(n);
             // MingW seems to set some funky environment variables like
@@ -985,7 +985,9 @@ mod tests {
         // Just assuming that we've got some contents in the current directory
         assert (vec::len(dirs) > 0u);
 
-        for vec::each(dirs) |dir| { log(debug, dir); }
+        for vec::each(dirs) |dir| {
+            log(debug, *dir);
+        }
     }
 
     #[test]
diff --git a/src/libcore/repr.rs b/src/libcore/repr.rs
index 55866cbdc52..435f1a5d18d 100644
--- a/src/libcore/repr.rs
+++ b/src/libcore/repr.rs
@@ -158,7 +158,7 @@ impl ReprVisitor {
 
     fn write_escaped_slice(slice: &str) {
         self.writer.write_char('"');
-        do str::chars_iter(slice) |ch| {
+        for str::chars_each(slice) |ch| {
             self.writer.write_escaped_char(ch);
         }
         self.writer.write_char('"');
@@ -563,7 +563,7 @@ impl ReprPrinterWrapper {
             let vec_repr = *vec_repr_ptr;
             let data_ptr = ptr::to_unsafe_ptr(&(*vec_repr).unboxed.data);
             let slice: &str = transmute((data_ptr, (*vec_repr).unboxed.fill));
-            do str::chars_iter(slice) |ch| {
+            for str::chars_each(slice) |ch| {
                 self.printer.writer.write_escaped_char(ch);
             }
             self.printer.writer.write_char('"');
@@ -686,7 +686,7 @@ impl ReprPrinterWrapper : TyVisitor {
             self.printer.writer.write_char('"');
             let slice_ptr: *&str = transmute(copy self.printer.ptr);
             let slice = *slice_ptr;
-            do str::chars_iter(slice) |ch| {
+            for str::chars_each(slice) |ch| {
                 self.printer.writer.write_escaped_char(ch);
             }
             self.printer.writer.write_char('"');
diff --git a/src/libcore/result.rs b/src/libcore/result.rs
index ece79ce078e..ea1a91d7a84 100644
--- a/src/libcore/result.rs
+++ b/src/libcore/result.rs
@@ -267,7 +267,7 @@ impl<T: Copy, E: Copy> Result<T, E> {
  *     }
  */
 fn map_vec<T,U:Copy,V:Copy>(
-    ts: &[T], op: fn(T) -> Result<V,U>) -> Result<~[V],U> {
+    ts: &[T], op: fn((&T)) -> Result<V,U>) -> Result<~[V],U> {
 
     let mut vs: ~[V] = ~[];
     vec::reserve(vs, vec::len(ts));
diff --git a/src/libcore/run.rs b/src/libcore/run.rs
index 379827871d7..2eda9d53659 100644
--- a/src/libcore/run.rs
+++ b/src/libcore/run.rs
@@ -87,7 +87,7 @@ fn with_argv<T>(prog: &str, args: &[~str],
     let mut argptrs = str::as_c_str(prog, |b| ~[b]);
     let mut tmps = ~[];
     for vec::each(args) |arg| {
-        let t = @copy arg;
+        let t = @copy *arg;
         vec::push(tmps, t);
         vec::push_all(argptrs, str::as_c_str(*t, |b| ~[b]));
     }
@@ -106,7 +106,7 @@ fn with_envp<T>(env: &Option<~[(~str,~str)]>,
         let mut ptrs = ~[];
 
         for vec::each(es) |e| {
-            let (k,v) = copy e;
+            let (k,v) = copy *e;
             let t = @(fmt!("%s=%s", k, v));
             vec::push(tmps, t);
             vec::push_all(ptrs, str::as_c_str(*t, |b| ~[b]));
@@ -131,7 +131,7 @@ fn with_envp<T>(env: &Option<~[(~str,~str)]>,
           Some(es) if !vec::is_empty(es) => {
             let mut blk : ~[u8] = ~[];
             for vec::each(es) |e| {
-                let (k,v) = e;
+                let (k,v) = *e;
                 let t = fmt!("%s=%s", k, v);
                 let mut v : ~[u8] = ::cast::reinterpret_cast(&t);
                 blk += v;
diff --git a/src/libcore/send_map.rs b/src/libcore/send_map.rs
index 28b36deb1d4..5dfc1f64367 100644
--- a/src/libcore/send_map.rs
+++ b/src/libcore/send_map.rs
@@ -17,7 +17,7 @@ trait SendMap<K:Eq Hash, V: Copy> {
     pure fn len(&const self) -> uint;
     pure fn is_empty(&const self) -> bool;
     pure fn contains_key(&const self, k: &K) -> bool;
-    pure fn each_ref(&self, blk: fn(k: &K, v: &V) -> bool);
+    pure fn each(&self, blk: fn(k: &K, v: &V) -> bool);
     pure fn each_key_ref(&self, blk: fn(k: &K) -> bool);
     pure fn each_value_ref(&self, blk: fn(v: &V) -> bool);
     pure fn find(&const self, k: &K) -> Option<V>;
@@ -311,7 +311,7 @@ mod linear {
             }
         }
 
-        pure fn each_ref(&self, blk: fn(k: &K, v: &V) -> bool) {
+        pure fn each(&self, blk: fn(k: &K, v: &V) -> bool) {
             for vec::each(self.buckets) |slot| {
                 let mut broke = false;
                 do slot.iter |bucket| {
@@ -323,12 +323,12 @@ mod linear {
             }
         }
 
-        pure fn each_key_ref(&self, blk: fn(k: &K) -> bool) {
-            self.each_ref(|k, _v| blk(k))
+        pure fn each_key(&self, blk: fn(k: &K) -> bool) {
+            self.each(|k, _v| blk(k))
         }
 
-        pure fn each_value_ref(&self, blk: fn(v: &V) -> bool) {
-            self.each_ref(|_k, v| blk(v))
+        pure fn each_value(&self, blk: fn(v: &V) -> bool) {
+            self.each(|_k, v| blk(v))
         }
     }
 
@@ -358,22 +358,6 @@ mod linear {
         }
 
     }
-
-    impl<K: Hash IterBytes Eq Copy, V: Copy> LinearMap<K,V> {
-        pure fn each(&self, blk: fn(+K,+V) -> bool) {
-            self.each_ref(|k,v| blk(copy *k, copy *v));
-        }
-    }
-    impl<K: Hash IterBytes Eq Copy, V> LinearMap<K,V> {
-        pure fn each_key(&self, blk: fn(+K) -> bool) {
-            self.each_key_ref(|k| blk(copy *k));
-        }
-    }
-    impl<K: Hash IterBytes Eq, V: Copy> LinearMap<K,V> {
-        pure fn each_value(&self, blk: fn(+V) -> bool) {
-            self.each_value_ref(|v| blk(copy *v));
-        }
-    }
 }
 
 #[test]
@@ -438,8 +422,8 @@ mod test {
         }
         let mut observed = 0;
         for m.each |k, v| {
-            assert v == k*2;
-            observed |= (1 << k);
+            assert *v == *k * 2;
+            observed |= (1 << *k);
         }
         assert observed == 0xFFFF_FFFF;
     }
diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index d785da3a462..f6baeb91be9 100644
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -72,12 +72,12 @@ export
    map,
    each, eachi,
    each_char, each_chari,
-   bytes_iter,
-   chars_iter,
-   split_char_iter,
-   splitn_char_iter,
-   words_iter,
-   lines_iter,
+   bytes_each,
+   chars_each,
+   split_char_each,
+   splitn_char_each,
+   words_each,
+   lines_each,
 
    // Searching
    find, find_from, find_between,
@@ -235,7 +235,9 @@ pure fn from_chars(chs: &[char]) -> ~str {
     let mut buf = ~"";
     unsafe {
         reserve(buf, chs.len());
-        for vec::each(chs) |ch| { push_char(buf, ch); }
+        for vec::each(chs) |ch| {
+            push_char(buf, *ch);
+        }
     }
     move buf
 }
@@ -289,7 +291,9 @@ pure fn append(+lhs: ~str, rhs: &str) -> ~str {
 /// Concatenate a vector of strings
 pure fn concat(v: &[~str]) -> ~str {
     let mut s: ~str = ~"";
-    for vec::each(v) |ss| { unsafe { push_str(s, ss) }; }
+    for vec::each(v) |ss| {
+        unsafe { push_str(s, *ss) };
+    }
     move s
 }
 
@@ -298,7 +302,7 @@ pure fn connect(v: &[~str], sep: &str) -> ~str {
     let mut s = ~"", first = true;
     for vec::each(v) |ss| {
         if first { first = false; } else { unsafe { push_str(s, sep); } }
-        unsafe { push_str(s, ss) };
+        unsafe { push_str(s, *ss) };
     }
     move s
 }
@@ -879,7 +883,7 @@ pure fn map(ss: &str, ff: fn(char) -> char) -> ~str {
     let mut result = ~"";
     unsafe {
         reserve(result, len(ss));
-        do chars_iter(ss) |cc| {
+        for chars_each(ss) |cc| {
             str::push_char(result, ff(cc));
         }
     }
@@ -887,12 +891,12 @@ pure fn map(ss: &str, ff: fn(char) -> char) -> ~str {
 }
 
 /// Iterate over the bytes in a string
-pure fn bytes_iter(ss: &str, it: fn(u8)) {
+pure fn bytes_each(ss: &str, it: fn(u8) -> bool) {
     let mut pos = 0u;
     let len = len(ss);
 
     while (pos < len) {
-        it(ss[pos]);
+        if !it(ss[pos]) { return; }
         pos += 1u;
     }
 }
@@ -933,40 +937,40 @@ pure fn each_chari(s: &str, it: fn(uint, char) -> bool) {
 }
 
 /// Iterate over the characters in a string
-pure fn chars_iter(s: &str, it: fn(char)) {
+pure fn chars_each(s: &str, it: fn(char) -> bool) {
     let mut pos = 0u;
     let len = len(s);
     while (pos < len) {
         let {ch, next} = char_range_at(s, pos);
         pos = next;
-        it(ch);
+        if !it(ch) { return; }
     }
 }
 
 /// Apply a function to each substring after splitting by character
-pure fn split_char_iter(ss: &str, cc: char, ff: fn(&&~str)) {
-   vec::iter(split_char(ss, cc), ff)
+pure fn split_char_each(ss: &str, cc: char, ff: fn(v: &str) -> bool) {
+    vec::each(split_char(ss, cc), |s| ff(*s))
 }
 
 /**
  * Apply a function to each substring after splitting by character, up to
  * `count` times
  */
-pure fn splitn_char_iter(ss: &str, sep: char, count: uint,
-                         ff: fn(&&~str)) {
-   vec::iter(splitn_char(ss, sep, count), ff)
+pure fn splitn_char_each(ss: &str, sep: char, count: uint,
+                         ff: fn(v: &str) -> bool) {
+    vec::each(splitn_char(ss, sep, count), |s| ff(*s))
 }
 
 /// Apply a function to each word
-pure fn words_iter(ss: &str, ff: fn(&&~str)) {
-    vec::iter(words(ss), ff)
+pure fn words_each(ss: &str, ff: fn(v: &str) -> bool) {
+    vec::each(words(ss), |s| ff(*s))
 }
 
 /**
  * Apply a function to each line (by '\n')
  */
-pure fn lines_iter(ss: &str, ff: fn(&&~str)) {
-    vec::iter(lines(ss), ff)
+pure fn lines_each(ss: &str, ff: fn(v: &str) -> bool) {
+    vec::each(lines(ss), |s| ff(*s))
 }
 
 /*
@@ -1518,7 +1522,7 @@ pure fn is_utf16(v: &[u16]) -> bool {
 /// Converts to a vector of `u16` encoded as UTF-16
 pure fn to_utf16(s: &str) -> ~[u16] {
     let mut u = ~[];
-    do chars_iter(s) |cch| {
+    for chars_each(s) |cch| {
         // Arithmetic with u32 literals is easier on the eyes than chars.
         let mut ch = cch as u32;
 
@@ -1947,7 +1951,9 @@ pure fn escape_default(s: &str) -> ~str {
     let mut out: ~str = ~"";
     unsafe {
         reserve_at_least(out, str::len(s));
-        chars_iter(s, |c| push_str(out, char::escape_default(c)));
+        for chars_each(s) |c| {
+            push_str(out, char::escape_default(c));
+        }
     }
     move out
 }
@@ -1957,7 +1963,9 @@ pure fn escape_unicode(s: &str) -> ~str {
     let mut out: ~str = ~"";
     unsafe {
         reserve_at_least(out, str::len(s));
-        chars_iter(s, |c| push_str(out, char::escape_unicode(c)));
+        for chars_each(s) |c| {
+            push_str(out, char::escape_unicode(c));
+        }
     }
     move out
 }
@@ -2094,7 +2102,7 @@ mod raw {
     /// Appends a vector of bytes to a string. (Not UTF-8 safe).
     unsafe fn push_bytes(&s: ~str, bytes: ~[u8]) {
         reserve_at_least(s, s.len() + bytes.len());
-        for vec::each(bytes) |byte| { push_byte(s, byte); }
+        for vec::each(bytes) |byte| { push_byte(s, *byte); }
     }
 
     /// Removes the last byte from a string and returns it. (Not UTF-8 safe).
@@ -3044,50 +3052,52 @@ mod tests {
     }
 
     #[test]
-    fn test_chars_iter() {
+    fn test_chars_each() {
         let mut i = 0;
-        do chars_iter(~"x\u03c0y") |ch| {
+        for chars_each(~"x\u03c0y") |ch| {
             match i {
               0 => assert ch == 'x',
               1 => assert ch == '\u03c0',
               2 => assert ch == 'y',
-              _ => fail ~"test_chars_iter failed"
+              _ => fail ~"test_chars_each failed"
             }
             i += 1;
         }
 
-        chars_iter(~"", |_ch| fail ); // should not fail
+        chars_each(~"", |_ch| fail ); // should not fail
     }
 
     #[test]
-    fn test_bytes_iter() {
+    fn test_bytes_each() {
         let mut i = 0;
 
-        do bytes_iter(~"xyz") |bb| {
+        for bytes_each(~"xyz") |bb| {
             match i {
               0 => assert bb == 'x' as u8,
               1 => assert bb == 'y' as u8,
               2 => assert bb == 'z' as u8,
-              _ => fail ~"test_bytes_iter failed"
+              _ => fail ~"test_bytes_each failed"
             }
             i += 1;
         }
 
-        bytes_iter(~"", |bb| assert bb == 0u8);
+        for bytes_each(~"") |bb| {
+            assert bb == 0u8;
+        }
     }
 
     #[test]
-    fn test_split_char_iter() {
+    fn test_split_char_each() {
         let data = ~"\nMary had a little lamb\nLittle lamb\n";
 
         let mut ii = 0;
 
-        do split_char_iter(data, ' ') |xx| {
+        for split_char_each(data, ' ') |xx| {
             match ii {
-              0 => assert ~"\nMary" == xx,
-              1 => assert ~"had"    == xx,
-              2 => assert ~"a"      == xx,
-              3 => assert ~"little" == xx,
+              0 => assert "\nMary" == xx,
+              1 => assert "had"    == xx,
+              2 => assert "a"      == xx,
+              3 => assert "little" == xx,
               _ => ()
             }
             ii += 1;
@@ -3095,16 +3105,16 @@ mod tests {
     }
 
     #[test]
-    fn test_splitn_char_iter() {
+    fn test_splitn_char_each() {
         let data = ~"\nMary had a little lamb\nLittle lamb\n";
 
         let mut ii = 0;
 
-        do splitn_char_iter(data, ' ', 2u) |xx| {
+        for splitn_char_each(data, ' ', 2u) |xx| {
             match ii {
-              0 => assert ~"\nMary" == xx,
-              1 => assert ~"had"    == xx,
-              2 => assert ~"a little lamb\nLittle lamb\n" == xx,
+              0 => assert "\nMary" == xx,
+              1 => assert "had"    == xx,
+              2 => assert "a little lamb\nLittle lamb\n" == xx,
               _ => ()
             }
             ii += 1;
@@ -3112,37 +3122,37 @@ mod tests {
     }
 
     #[test]
-    fn test_words_iter() {
+    fn test_words_each() {
         let data = ~"\nMary had a little lamb\nLittle lamb\n";
 
         let mut ii = 0;
 
-        do words_iter(data) |ww| {
+        for words_each(data) |ww| {
             match ii {
-              0 => assert ~"Mary"   == ww,
-              1 => assert ~"had"    == ww,
-              2 => assert ~"a"      == ww,
-              3 => assert ~"little" == ww,
+              0 => assert "Mary"   == ww,
+              1 => assert "had"    == ww,
+              2 => assert "a"      == ww,
+              3 => assert "little" == ww,
               _ => ()
             }
             ii += 1;
         }
 
-        words_iter(~"", |_x| fail); // should not fail
+        words_each(~"", |_x| fail); // should not fail
     }
 
     #[test]
-    fn test_lines_iter () {
+    fn test_lines_each () {
         let lf = ~"\nMary had a little lamb\nLittle lamb\n";
 
         let mut ii = 0;
 
-        do lines_iter(lf) |x| {
+        for lines_each(lf) |x| {
             match ii {
-                0 => assert ~"" == x,
-                1 => assert ~"Mary had a little lamb" == x,
-                2 => assert ~"Little lamb" == x,
-                3 => assert ~"" == x,
+                0 => assert "" == x,
+                1 => assert "Mary had a little lamb" == x,
+                2 => assert "Little lamb" == x,
+                3 => assert "" == x,
                 _ => ()
             }
             ii += 1;
@@ -3221,7 +3231,7 @@ mod tests {
                0x000a_u16 ]) ];
 
         for vec::each(pairs) |p| {
-            let (s, u) = copy p;
+            let (s, u) = copy *p;
             assert to_utf16(s) == u;
             assert from_utf16(u) == s;
             assert from_utf16(to_utf16(s)) == s;
diff --git a/src/libcore/task.rs b/src/libcore/task.rs
index adeebcf344e..070da8ffd4a 100644
--- a/src/libcore/task.rs
+++ b/src/libcore/task.rs
@@ -888,7 +888,7 @@ fn taskset_remove(tasks: &mut TaskSet, task: *rust_task) {
     assert was_present;
 }
 fn taskset_each(tasks: &TaskSet, blk: fn(+*rust_task) -> bool) {
-    tasks.each_key(blk)
+    tasks.each_key(|k| blk(*k))
 }
 
 // One of these per group of linked-failure tasks.
diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
index 6ee360e3e13..820e4df647a 100644
--- a/src/libcore/vec.rs
+++ b/src/libcore/vec.rs
@@ -76,12 +76,8 @@ export zip, zip_slice;
 export swap;
 export reverse;
 export reversed;
-export iter, iter_between, each, eachi, reach, reachi;
-export each_ref, each_mut_ref, each_const_ref;
+export each, each_mut, each_const, eachi, reach, reachi;
 export iter2;
-export iteri;
-export riter;
-export riteri;
 export permute;
 export windowed;
 export as_imm_buf;
@@ -755,7 +751,7 @@ fn grow_set<T: Copy>(&v: ~[mut T], index: uint, initval: T, val: T) {
 pure fn map<T, U>(v: &[T], f: fn(T) -> U) -> ~[U] {
     let mut result = ~[];
     unsafe{reserve(result, len(v));}
-    for each(v) |elem| { unsafe { push(result, f(elem)); } }
+    for each(v) |elem| { unsafe { push(result, f(*elem)); } }
     move result
 }
 
@@ -781,7 +777,7 @@ pure fn mapi<T, U>(v: &[T], f: fn(uint, T) -> U) -> ~[U] {
  */
 pure fn flat_map<T, U>(v: &[T], f: fn(T) -> ~[U]) -> ~[U] {
     let mut result = ~[];
-    for each(v) |elem| { unsafe{ push_all_move(result, f(elem)); } }
+    for each(v) |elem| { unsafe{ push_all_move(result, f(*elem)); } }
     move result
 }
 
@@ -809,7 +805,7 @@ pure fn filter_map<T, U: Copy>(v: &[T], f: fn(T) -> Option<U>)
     -> ~[U] {
     let mut result = ~[];
     for each(v) |elem| {
-        match f(elem) {
+        match f(*elem) {
           None => {/* no-op */ }
           Some(result_elem) => unsafe { push(result, result_elem); }
         }
@@ -827,7 +823,7 @@ pure fn filter_map<T, U: Copy>(v: &[T], f: fn(T) -> Option<U>)
 pure fn filter<T: Copy>(v: &[T], f: fn(T) -> bool) -> ~[T] {
     let mut result = ~[];
     for each(v) |elem| {
-        if f(elem) { unsafe { push(result, elem); } }
+        if f(*elem) { unsafe { push(result, *elem); } }
     }
     move result
 }
@@ -839,7 +835,7 @@ pure fn filter<T: Copy>(v: &[T], f: fn(T) -> bool) -> ~[T] {
  */
 pure fn concat<T: Copy>(v: &[~[T]]) -> ~[T] {
     let mut r = ~[];
-    for each(v) |inner| { unsafe { push_all(r, inner); } }
+    for each(v) |inner| { unsafe { push_all(r, *inner); } }
     move r
 }
 
@@ -849,7 +845,7 @@ pure fn connect<T: Copy>(v: &[~[T]], sep: T) -> ~[T] {
     let mut first = true;
     for each(v) |inner| {
         if first { first = false; } else { unsafe { push(r, sep); } }
-        unsafe { push_all(r, inner) };
+        unsafe { push_all(r, *inner) };
     }
     move r
 }
@@ -857,8 +853,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(v) |elt| {
+        accum = p(accum, *elt);
     }
     return accum;
 }
@@ -866,7 +862,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;
@@ -878,7 +874,7 @@ pure fn foldr<T, U: Copy>(v: &[T], z: U, p: fn(T, U) -> U) -> U {
  * If the vector contains no elements then false is returned.
  */
 pure fn any<T>(v: &[T], f: fn(T) -> bool) -> bool {
-    for each(v) |elem| { if f(elem) { return true; } }
+    for each(v) |elem| { if f(*elem) { return true; } }
     return false;
 }
 
@@ -905,7 +901,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) -> bool) -> bool {
-    for each(v) |elem| { if !f(elem) { return false; } }
+    for each(v) |elem| { if !f(*elem) { return false; } }
     return true;
 }
 
@@ -935,14 +931,14 @@ 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 {
-    for each(v) |elt| { if x == elt { return true; } }
+    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 {
     let mut cnt = 0u;
-    for each(v) |elt| { if x == elt { cnt += 1u; } }
+    for each(v) |elt| { if x == *elt { cnt += 1u; } }
     return cnt;
 }
 
@@ -1070,7 +1066,7 @@ pure fn rposition_between<T>(v: &[T], start: uint, end: uint,
 pure fn unzip_slice<T: Copy, U: Copy>(v: &[(T, U)]) -> (~[T], ~[U]) {
     let mut as_ = ~[], bs = ~[];
     for each(v) |p| {
-        let (a, b) = p;
+        let (a, b) = *p;
         unsafe {
             vec::push(as_, a);
             vec::push(bs, b);
@@ -1150,7 +1146,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,49 +1159,12 @@ 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.
  */
 #[inline(always)]
-pure fn each<T>(v: &[T], f: fn(T) -> bool) {
+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
@@ -1217,7 +1175,8 @@ pure fn each<T>(v: &[T], f: fn(T) -> bool) {
         let mut p = p;
         while n > 0u {
             unsafe {
-                if !f(*p) { break; }
+                let q = cast::copy_lifetime_vec(v, &*p);
+                if !f(q) { break; }
                 p = ptr::offset(p, 1u);
             }
             n -= 1u;
@@ -1225,30 +1184,11 @@ pure fn each<T>(v: &[T], f: fn(T) -> bool) {
     }
 }
 
-/**
- * Iterates over a vector, with option to break
- *
- * Return true to continue, false to break.
- */
-#[inline(always)]
-pure fn each_ref<T>(v: &r/[T], f: fn(v: &r/T) -> bool) {
-    // this is not the most efficient impl, as it repeats the bound checks,
-    // but it's good enough
-    let mut i = 0;
-    let n = v.len();
-    while i < n {
-        if !f(&v[i]) {
-            return;
-        }
-        i += 1;
-    }
-}
-
 /// Like `each()`, but for the case where you have
 /// a vector with mutable contents and you would like
 /// to mutate the contents as you iterate.
 #[inline(always)]
-fn each_mut_ref<T>(v: &[mut T], f: fn(elem: &mut T) -> bool) {
+fn each_mut<T>(v: &[mut T], f: fn(elem: &mut T) -> bool) {
     let mut i = 0;
     let n = v.len();
     while i < n {
@@ -1262,7 +1202,7 @@ fn each_mut_ref<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_ref<T>(v: &[const T], f: fn(elem: &const T) -> bool) {
+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 {
@@ -1345,43 +1285,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 +1317,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 +1529,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 +1549,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) }
@@ -2013,7 +1880,13 @@ mod bytes {
 // required in the slice.
 
 impl<A> &[A]: iter::BaseIter<A> {
-    pure fn each(blk: fn(A) -> bool) { each(self, blk) }
+    pure fn each(blk: fn(A) -> bool) {
+        for each(self) |e| {
+            if (!blk(*e)) {
+                return;
+            }
+        }
+    }
     pure fn size_hint() -> Option<uint> { Some(len(self)) }
 }
 
@@ -2465,55 +2338,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::<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(~[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;
     }