replace explicit calls to vec::each with vec::each_ref, partially demode str

Author: nikomatsakis

src/compiletest/runtest.rs

@@ -425,8 +425,8 @@ fn compose_and_run_compiler(
     let extra_link_args = ~[~"-L",
                             aux_output_dir_name(config, testfile).to_str()];
 
-    do vec::iter(props.aux_builds) |rel_ab| {
-        let abs_ab = config.aux_base.push_rel(&Path(rel_ab));
+    for vec::each_ref(props.aux_builds) |rel_ab| {
+        let abs_ab = config.aux_base.push_rel(&Path(*rel_ab));
         let aux_args =
             make_compile_args(config, props, ~[~"--lib"] + extra_link_args,
                               |a,b| make_lib_name(a, b, testfile), &abs_ab);

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));
         }
     }
 }

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)
         }

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;
     }
 

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,

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> {

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]

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

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('"');

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)

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;

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) {