about summary refs log tree commit diff
path: root/src/libcore
diff options
context:
space:
mode:
Diffstat (limited to 'src/libcore')
-rw-r--r--src/libcore/at_vec.rs6
-rw-r--r--src/libcore/either.rs12
-rw-r--r--src/libcore/hash.rs8
-rw-r--r--src/libcore/io.rs4
-rw-r--r--src/libcore/iter-trait/dvec.rs7
-rw-r--r--src/libcore/os.rs12
-rw-r--r--src/libcore/pipes.rs2
-rw-r--r--src/libcore/repr.rs6
-rw-r--r--src/libcore/result.rs4
-rw-r--r--src/libcore/run.rs12
-rw-r--r--src/libcore/send_map.rs2
-rw-r--r--src/libcore/str.rs134
-rw-r--r--src/libcore/to_str.rs2
-rw-r--r--src/libcore/vec.rs160
14 files changed, 140 insertions, 231 deletions
diff --git a/src/libcore/at_vec.rs b/src/libcore/at_vec.rs
index 069bc625623..b9c0122df3f 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_ref(lhs) |x| { push(*x); }
         for uint::range(0, rhs.len()) |i| { push(rhs[i]); }
     }
 }
@@ -100,8 +100,8 @@ pure fn append<T: Copy>(lhs: @[T], rhs: &[const T]) -> @[T] {
 /// Apply a function to each element of a vector and return the results
 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));
+        for vec::each_ref(v) |elem| {
+            push(f(*elem));
         }
     }
 }
diff --git a/src/libcore/either.rs b/src/libcore/either.rs
index b97fd244940..da7f1894a03 100644
--- a/src/libcore/either.rs
+++ b/src/libcore/either.rs
@@ -33,8 +33,8 @@ fn lefts<T: Copy, U>(eithers: &[Either<T, U>]) -> ~[T] {
     //! Extracts from a vector of either all the left values
 
     let mut result: ~[T] = ~[];
-    for vec::each(eithers) |elt| {
-        match elt {
+    for vec::each_ref(eithers) |elt| {
+        match *elt {
           Left(l) => vec::push(result, l),
           _ => { /* fallthrough */ }
         }
@@ -46,8 +46,8 @@ fn rights<T, U: Copy>(eithers: &[Either<T, U>]) -> ~[U] {
     //! Extracts from a vector of either all the right values
 
     let mut result: ~[U] = ~[];
-    for vec::each(eithers) |elt| {
-        match elt {
+    for vec::each_ref(eithers) |elt| {
+        match *elt {
           Right(r) => vec::push(result, r),
           _ => { /* fallthrough */ }
         }
@@ -66,8 +66,8 @@ 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 {
+    for vec::each_ref(eithers) |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..ab06814c008 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_ref(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_ref(*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..6856c917e4f 100644
--- a/src/libcore/io.rs
+++ b/src/libcore/io.rs
@@ -450,8 +450,8 @@ fn mk_file_writer(path: &Path, flags: ~[FileFlag])
     fn wb() -> c_int { O_WRONLY as c_int }
 
     let mut fflags: c_int = wb();
-    for vec::each(flags) |f| {
-        match f {
+    for vec::each_ref(flags) |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..6164283e858 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| {
+            vec::each(v, f);
+            move v
+        }
+    }
 }
 
 pure fn SIZE_HINT<A>(self: IMPL_T<A>) -> Option<uint> {
diff --git a/src/libcore/os.rs b/src/libcore/os.rs
index 3a15179e0c6..2404f5deff7 100644
--- a/src/libcore/os.rs
+++ b/src/libcore/os.rs
@@ -210,8 +210,8 @@ 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);
+            for vec::each_ref(rustrt::rust_env_pairs()) |p| {
+                let vs = str::splitn_char(*p, '=', 1u);
                 assert vec::len(vs) == 2u;
                 vec::push(pairs, (copy vs[0], copy vs[1]));
             }
@@ -892,8 +892,8 @@ mod tests {
     fn test_env_getenv() {
         let e = env();
         assert vec::len(e) > 0u;
-        for vec::each(e) |p| {
-            let (n, v) = copy p;
+        for vec::each_ref(e) |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_ref(dirs) |dir| {
+            log(debug, *dir);
+        }
     }
 
     #[test]
diff --git a/src/libcore/pipes.rs b/src/libcore/pipes.rs
index 3adb77873c2..4fc9c724843 100644
--- a/src/libcore/pipes.rs
+++ b/src/libcore/pipes.rs
@@ -1099,7 +1099,7 @@ impl<T: Send> PortSet<T> : Recv<T> {
     pure fn peek() -> bool {
         // It'd be nice to use self.port.each, but that version isn't
         // pure.
-        for vec::each(self.ports) |p| {
+        for vec::each_ref(self.ports) |p| {
             if p.peek() { return true }
         }
         false
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..d11e90149d2 100644
--- a/src/libcore/result.rs
+++ b/src/libcore/result.rs
@@ -267,11 +267,11 @@ 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));
-    for vec::each(ts) |t| {
+    for vec::each_ref(ts) |t| {
         match op(t) {
           Ok(v) => vec::push(vs, v),
           Err(u) => return Err(u)
diff --git a/src/libcore/run.rs b/src/libcore/run.rs
index cc93d30ecd6..1bc0636ccda 100644
--- a/src/libcore/run.rs
+++ b/src/libcore/run.rs
@@ -86,8 +86,8 @@ fn with_argv<T>(prog: &str, args: &[~str],
                 cb: fn(**libc::c_char) -> T) -> T {
     let mut argptrs = str::as_c_str(prog, |b| ~[b]);
     let mut tmps = ~[];
-    for vec::each(args) |arg| {
-        let t = @copy arg;
+    for vec::each_ref(args) |arg| {
+        let t = @copy *arg;
         vec::push(tmps, t);
         vec::push_all(argptrs, str::as_c_str(*t, |b| ~[b]));
     }
@@ -105,8 +105,8 @@ fn with_envp<T>(env: &Option<~[(~str,~str)]>,
         let mut tmps = ~[];
         let mut ptrs = ~[];
 
-        for vec::each(es) |e| {
-            let (k,v) = copy e;
+        for vec::each_ref(es) |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]));
@@ -130,8 +130,8 @@ fn with_envp<T>(env: &Option<~[(~str,~str)]>,
         match *env {
           Some(es) if !vec::is_empty(es) => {
             let mut blk : ~[u8] = ~[];
-            for vec::each(es) |e| {
-                let (k,v) = e;
+            for vec::each_ref(es) |e| {
+                let (k,v) = *e;
                 let t = fmt!("%s=%s", k, v);
                 let mut v : ~[u8] = ::unsafe::reinterpret_cast(&t);
                 blk += v;
diff --git a/src/libcore/send_map.rs b/src/libcore/send_map.rs
index 28b36deb1d4..0a668157892 100644
--- a/src/libcore/send_map.rs
+++ b/src/libcore/send_map.rs
@@ -312,7 +312,7 @@ mod linear {
         }
 
         pure fn each_ref(&self, blk: fn(k: &K, v: &V) -> bool) {
-            for vec::each(self.buckets) |slot| {
+            for vec::each_ref(self.buckets) |slot| {
                 let mut broke = false;
                 do slot.iter |bucket| {
                     if !blk(&bucket.key, &bucket.value) {
diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index d785da3a462..c97588e0a33 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_ref(chs) |ch| {
+            push_char(buf, *ch);
+        }
     }
     move buf
 }
@@ -289,16 +291,18 @@ 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_ref(v) |ss| {
+        unsafe { push_str(s, *ss) };
+    }
     move s
 }
 
 /// Concatenate a vector of strings, placing a given separator between each
 pure fn connect(v: &[~str], sep: &str) -> ~str {
     let mut s = ~"", first = true;
-    for vec::each(v) |ss| {
+    for vec::each_ref(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_ref(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_ref(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_ref(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_ref(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_ref(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;
@@ -3220,8 +3230,8 @@ mod tests {
                0xd801_u16, 0xdc95_u16, 0xd801_u16, 0xdc86_u16,
                0x000a_u16 ]) ];
 
-        for vec::each(pairs) |p| {
-            let (s, u) = copy p;
+        for vec::each_ref(pairs) |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/to_str.rs b/src/libcore/to_str.rs
index 358ad0e281f..69c905f68fd 100644
--- a/src/libcore/to_str.rs
+++ b/src/libcore/to_str.rs
@@ -75,7 +75,7 @@ impl<A: ToStr Copy, B: ToStr Copy, C: ToStr Copy> (A, B, C): ToStr {
 impl<A: ToStr> ~[A]: ToStr {
     fn to_str() -> ~str {
         let mut acc = ~"[", first = true;
-        for vec::each(self) |elt| {
+        for vec::each_ref(self) |elt| {
             if first { first = false; }
             else { str::push_str(acc, ~", "); }
             str::push_str(acc, elt.to_str());
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;
     }
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2025-11-03 07:02:08 +0000