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

12 files changed, 88 insertions, 68 deletions

diff --git a/src/libstd/arc.rs b/src/libstd/arc.rs
index a50e897358c..505385aa9df 100644
--- a/src/libstd/arc.rs
+++ b/src/libstd/arc.rs
@@ -642,6 +642,7 @@ mod tests {
                 c.send(());
             }
         }
+
         // Readers try to catch the writer in the act
         let mut children = ~[];
         for 5.times {
@@ -652,8 +653,10 @@ mod tests {
                 }
             }
         }
+
         // Wait for children to pass their asserts
-        for vec::each(children) |r| { future::get(&r); }
+        for vec::each_ref(children) |r| { future::get(r); }
+
         // Wait for writer to finish
         p.recv();
         do arc.read |num| { assert *num == 10; }
@@ -713,8 +716,8 @@ mod tests {
                 assert *state == 42;
                 *state = 31337;
                 // send to other readers
-                for vec::each(reader_convos) |x| {
-                    match x {
+                for vec::each_ref(reader_convos) |x| {
+                    match *x {
                         (rc, _) => rc.send(()),
                     }
                 }
@@ -722,8 +725,8 @@ mod tests {
             let read_mode = arc.downgrade(write_mode);
             do (&read_mode).read |state| {
                 // complete handshake with other readers
-                for vec::each(reader_convos) |x| {
-                    match x {
+                for vec::each_ref(reader_convos) |x| {
+                    match *x {
                         (_, rp) => rp.recv(),
                     }
                 }
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
index 36492834c2a..788802ed58c 100644
--- a/src/libstd/getopts.rs
+++ b/src/libstd/getopts.rs
@@ -292,16 +292,16 @@ fn getopts(args: &[~str], opts: &[Opt]) -> Result unsafe {
                 }
             }
             let mut name_pos = 0u;
-            for vec::each(names) |nm| {
+            for vec::each_ref(names) |nm| {
                 name_pos += 1u;
-                let optid = match find_opt(opts, nm) {
+                let optid = match find_opt(opts, *nm) {
                   Some(id) => id,
-                  None => return Err(UnrecognizedOption(name_str(&nm)))
+                  None => return Err(UnrecognizedOption(name_str(nm)))
                 };
                 match opts[optid].hasarg {
                   No => {
                     if !option::is_none::<~str>(i_arg) {
-                        return Err(UnexpectedArgument(name_str(&nm)));
+                        return Err(UnexpectedArgument(name_str(nm)));
                     }
                     vec::push(vals[optid], Given);
                   }
@@ -318,7 +318,7 @@ fn getopts(args: &[~str], opts: &[Opt]) -> Result unsafe {
                         vec::push(vals[optid],
                                   Val(option::get::<~str>(i_arg)));
                     } else if i + 1u == l {
-                        return Err(ArgumentMissing(name_str(&nm)));
+                        return Err(ArgumentMissing(name_str(nm)));
                     } else { i += 1u; vec::push(vals[optid], Val(args[i])); }
                   }
                 }
@@ -366,8 +366,8 @@ fn opt_present(+mm: Matches, nm: &str) -> bool {
 
 /// Returns true if any of several options were matched
 fn opts_present(+mm: Matches, names: &[~str]) -> bool {
-    for vec::each(names) |nm| {
-        match find_opt(mm.opts, mkname(nm)) {
+    for vec::each_ref(names) |nm| {
+        match find_opt(mm.opts, mkname(*nm)) {
           Some(_) => return true,
           None    => ()
         }
@@ -393,8 +393,8 @@ fn opt_str(+mm: Matches, nm: &str) -> ~str {
  * option took an argument
  */
 fn opts_str(+mm: Matches, names: &[~str]) -> ~str {
-    for vec::each(names) |nm| {
-        match opt_val(mm, nm) {
+    for vec::each_ref(names) |nm| {
+        match opt_val(mm, *nm) {
           Val(s) => return s,
           _ => ()
         }
@@ -411,8 +411,8 @@ fn opts_str(+mm: Matches, names: &[~str]) -> ~str {
  */
 fn opt_strs(+mm: Matches, nm: &str) -> ~[~str] {
     let mut acc: ~[~str] = ~[];
-    for vec::each(opt_vals(mm, nm)) |v| {
-        match v { Val(s) => vec::push(acc, s), _ => () }
+    for vec::each_ref(opt_vals(mm, nm)) |v| {
+        match *v { Val(s) => vec::push(acc, s), _ => () }
     }
     return acc;
 }
diff --git a/src/libstd/json.rs b/src/libstd/json.rs
index b269ca84104..88b46f490ac 100644
--- a/src/libstd/json.rs
+++ b/src/libstd/json.rs
@@ -179,7 +179,7 @@ fn to_writer_pretty(wr: io::Writer, j: Json, indent: uint) {
 
 fn escape_str(s: &str) -> ~str {
     let mut escaped = ~"\"";
-    do str::chars_iter(s) |c| {
+    for str::chars_each(s) |c| {
         match c {
           '"' => escaped += ~"\\\"",
           '\\' => escaped += ~"\\\\",
@@ -834,8 +834,8 @@ mod tests {
     fn mk_dict(items: &[(~str, Json)]) -> Json {
         let d = map::str_hash();
 
-        do vec::iter(items) |item| {
-            let (key, value) = copy item;
+        for vec::each_ref(items) |item| {
+            let (key, value) = copy *item;
             d.insert(key, value);
         };
 
diff --git a/src/libstd/map.rs b/src/libstd/map.rs
index 1726e1f581f..4b41b81d4e5 100644
--- a/src/libstd/map.rs
+++ b/src/libstd/map.rs
@@ -435,9 +435,12 @@ fn vec_from_set<T:Eq IterBytes Hash Copy>(s: Set<T>) -> ~[T] {
 fn hash_from_vec<K: Eq IterBytes Hash Const Copy, V: Copy>(
     items: &[(K, V)]) -> HashMap<K, V> {
     let map = HashMap();
-    do vec::iter(items) |item| {
-        let (key, value) = item;
-        map.insert(key, value);
+    for vec::each_ref(items) |item| {
+        match *item {
+            (key, value) => {
+                map.insert(key, value);
+            }
+        }
     }
     map
 }
diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs
index 4e23e3a1592..13442994b65 100644
--- a/src/libstd/net_ip.rs
+++ b/src/libstd/net_ip.rs
@@ -363,13 +363,13 @@ mod test {
         let results = result::unwrap(ga_result);
         log(debug, fmt!("test_get_addr: Number of results for %s: %?",
                         localhost_name, vec::len(results)));
-        for vec::each(results) |r| {
-            let ipv_prefix = match r {
+        for vec::each_ref(results) |r| {
+            let ipv_prefix = match *r {
               Ipv4(_) => ~"IPv4",
               Ipv6(_) => ~"IPv6"
             };
             log(debug, fmt!("test_get_addr: result %s: '%s'",
-                            ipv_prefix, format_addr(&r)));
+                            ipv_prefix, format_addr(r)));
         }
         // at least one result.. this is going to vary from system
         // to system, based on stuff like the contents of /etc/hosts
diff --git a/src/libstd/serialization.rs b/src/libstd/serialization.rs
index 64254d5b2e5..72b3c747e35 100644
--- a/src/libstd/serialization.rs
+++ b/src/libstd/serialization.rs
@@ -91,7 +91,7 @@ trait Deserializer {
 
 fn emit_from_vec<S: Serializer, T>(s: S, v: ~[T], f: fn(T)) {
     do s.emit_vec(vec::len(v)) {
-        do vec::iteri(v) |i,e| {
+        for vec::eachi(v) |i,e| {
             do s.emit_vec_elt(i) {
                 f(e)
             }
diff --git a/src/libstd/sha1.rs b/src/libstd/sha1.rs
index 9808b15dc66..fc34ca0cd10 100644
--- a/src/libstd/sha1.rs
+++ b/src/libstd/sha1.rs
@@ -65,8 +65,8 @@ fn sha1() -> Sha1 {
 
     fn add_input(st: &Sha1State, msg: &[u8]) {
         assert (!st.computed);
-        for vec::each(msg) |element| {
-            st.msg_block[st.msg_block_idx] = element;
+        for vec::each_ref(msg) |element| {
+            st.msg_block[st.msg_block_idx] = *element;
             st.msg_block_idx += 1u;
             st.len_low += 8u32;
             if st.len_low == 0u32 {
@@ -240,7 +240,9 @@ fn sha1() -> Sha1 {
         fn result_str() -> ~str {
             let rr = mk_result(&self);
             let mut s = ~"";
-            for vec::each(rr) |b| { s += uint::to_str(b as uint, 16u); }
+            for vec::each_ref(rr) |b| {
+                s += uint::to_str(*b as uint, 16u);
+            }
             return s;
         }
     }
@@ -329,7 +331,7 @@ mod tests {
         // Test that it works when accepting the message all at once
 
         let sh = sha1::sha1();
-        for vec::each(tests) |t| {
+        for vec::each_ref(tests) |t| {
             sh.input_str(t.input);
             let out = sh.result();
             check_vec_eq(t.output, out);
@@ -338,7 +340,7 @@ mod tests {
 
 
         // Test that it works when accepting the message in pieces
-        for vec::each(tests) |t| {
+        for vec::each_ref(tests) |t| {
             let len = str::len(t.input);
             let mut left = len;
             while left > 0u {
diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs
index 74ee337f5b5..97bc1b0a115 100644
--- a/src/libstd/sort.rs
+++ b/src/libstd/sort.rs
@@ -259,8 +259,8 @@ mod test_qsort {
         let immut_names = vec::from_mut(names);
 
         let pairs = vec::zip(expected, immut_names);
-        for vec::each(pairs) |p| {
-            let (a, b) = p;
+        for vec::each_ref(pairs) |p| {
+            let (a, b) = *p;
             debug!("%d %d", a, b);
             assert (a == b);
         }
diff --git a/src/libstd/sync.rs b/src/libstd/sync.rs
index f5528f7a79c..53d41bce977 100644
--- a/src/libstd/sync.rs
+++ b/src/libstd/sync.rs
@@ -941,7 +941,7 @@ mod tests {
                     }
                 }
             }
-            for vec::each(sibling_convos) |p| {
+            for vec::each_ref(sibling_convos) |p| {
                 let _ = p.recv(); // wait for sibling to get in the mutex
             }
             do m2.lock { }
@@ -950,7 +950,7 @@ mod tests {
         };
         assert result.is_err();
         // child task must have finished by the time try returns
-        for vec::each(p.recv()) |p| { p.recv(); } // wait on all its siblings
+        for vec::each_ref(p.recv()) |p| { p.recv(); } // wait on all its siblings
         do m.lock_cond |cond| {
             let woken = cond.broadcast();
             assert woken == 0;
diff --git a/src/libstd/term.rs b/src/libstd/term.rs
index 34244e95c0c..6af6a5181ec 100644
--- a/src/libstd/term.rs
+++ b/src/libstd/term.rs
@@ -39,8 +39,8 @@ fn color_supported() -> bool {
                            ~"screen-bce", ~"xterm-256color"];
     return match os::getenv(~"TERM") {
           option::Some(env) => {
-            for vec::each(supported_terms) |term| {
-                if term == env { return true; }
+            for vec::each_ref(supported_terms) |term| {
+                if *term == env { return true; }
             }
             false
           }
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index 76b6310c853..3d4549dd423 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -226,8 +226,8 @@ fn print_failures(st: ConsoleTestState) {
     let failures = copy st.failures;
     let failures = vec::map(failures, |test| test.name);
     let failures = sort::merge_sort(|x, y| str::le(*x, *y), failures);
-    for vec::each(failures) |name| {
-        st.out.write_line(fmt!("    %s", name));
+    for vec::each_ref(failures) |name| {
+        st.out.write_line(fmt!("    %s", *name));
     }
 }
 
@@ -535,30 +535,34 @@ mod tests {
              ~"test::sort_tests"];
         let tests =
         {
-        let testfn = fn~() { };
-        let mut tests = ~[];
-            for vec::each(names) |name| {
-            let test = {name: name, testfn: copy testfn, ignore: false,
-                        should_fail: false};
-            tests += ~[test];
-        }
-        tests
-    };
-    let filtered = filter_tests(opts, tests);
+            let testfn = fn~() { };
+            let mut tests = ~[];
+            for vec::each_ref(names) |name| {
+                let test = {name: *name, testfn: copy testfn, ignore: false,
+                            should_fail: false};
+                vec::push(tests, test);
+            }
+            tests
+        };
+        let filtered = filter_tests(opts, tests);
 
-    let expected =
-        ~[~"int::test_pow", ~"int::test_to_str", ~"sha1::test",
-          ~"test::do_not_run_ignored_tests",
-          ~"test::filter_for_ignored_option",
-          ~"test::first_free_arg_should_be_a_filter",
-          ~"test::ignored_tests_result_in_ignored",
-          ~"test::parse_ignored_flag",
-          ~"test::sort_tests"];
+        let expected =
+            ~[~"int::test_pow", ~"int::test_to_str", ~"sha1::test",
+              ~"test::do_not_run_ignored_tests",
+              ~"test::filter_for_ignored_option",
+              ~"test::first_free_arg_should_be_a_filter",
+              ~"test::ignored_tests_result_in_ignored",
+              ~"test::parse_ignored_flag",
+              ~"test::sort_tests"];
 
-    let pairs = vec::zip(expected, filtered);
+        let pairs = vec::zip(expected, filtered);
 
-    for vec::each(pairs) |p| { let (a, b) = copy p; assert (a == b.name); }
-}
+        for vec::each_ref(pairs) |p| {
+            match *p {
+                (a, b) => { assert (a == b.name); }
+            }
+        }
+    }
 }
 
 
diff --git a/src/libstd/time.rs b/src/libstd/time.rs
index 84d4e49ef90..df3534fdf86 100644
--- a/src/libstd/time.rs
+++ b/src/libstd/time.rs
@@ -1023,7 +1023,7 @@ mod tests {
             }
         }
 
-        [
+        for vec::each_ref([
             ~"Sunday",
             ~"Monday",
             ~"Tuesday",
@@ -1031,9 +1031,11 @@ mod tests {
             ~"Thursday",
             ~"Friday",
             ~"Saturday"
-        ]/_.iter(|day| assert test(day, ~"%A"));
+        ]) |day| {
+            assert test(*day, ~"%A");
+        }
 
-        [
+        for vec::each_ref([
             ~"Sun",
             ~"Mon",
             ~"Tue",
@@ -1041,9 +1043,11 @@ mod tests {
             ~"Thu",
             ~"Fri",
             ~"Sat"
-        ]/_.iter(|day| assert test(day, ~"%a"));
+        ]) |day| {
+            assert test(*day, ~"%a");
+        }
 
-        [
+        for vec::each_ref([
             ~"January",
             ~"February",
             ~"March",
@@ -1056,9 +1060,11 @@ mod tests {
             ~"October",
             ~"November",
             ~"December"
-        ]/_.iter(|day| assert test(day, ~"%B"));
+        ]) |day| {
+            assert test(*day, ~"%B");
+        }
 
-        [
+        for vec::each_ref([
             ~"Jan",
             ~"Feb",
             ~"Mar",
@@ -1071,7 +1077,9 @@ mod tests {
             ~"Oct",
             ~"Nov",
             ~"Dec"
-        ]/_.iter(|day| assert test(day, ~"%b"));
+        ]) |day| {
+            assert test(*day, ~"%b");
+        }
 
         assert test(~"19", ~"%C");
         assert test(~"Fri Feb 13 23:31:30 2009", ~"%c");