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

This reverts commit 1be24f0758d3075d2e7f141f8831bb8a233ce86e.

Not quite ready.

12 files changed, 68 insertions, 88 deletions

diff --git a/src/libstd/arc.rs b/src/libstd/arc.rs
index 505385aa9df..a50e897358c 100644
--- a/src/libstd/arc.rs
+++ b/src/libstd/arc.rs
@@ -642,7 +642,6 @@ mod tests {
                 c.send(());
             }
         }
-
         // Readers try to catch the writer in the act
         let mut children = ~[];
         for 5.times {
@@ -653,10 +652,8 @@ mod tests {
                 }
             }
         }
-
         // Wait for children to pass their asserts
-        for vec::each_ref(children) |r| { future::get(r); }
-
+        for vec::each(children) |r| { future::get(&r); }
         // Wait for writer to finish
         p.recv();
         do arc.read |num| { assert *num == 10; }
@@ -716,8 +713,8 @@ mod tests {
                 assert *state == 42;
                 *state = 31337;
                 // send to other readers
-                for vec::each_ref(reader_convos) |x| {
-                    match *x {
+                for vec::each(reader_convos) |x| {
+                    match x {
                         (rc, _) => rc.send(()),
                     }
                 }
@@ -725,8 +722,8 @@ mod tests {
             let read_mode = arc.downgrade(write_mode);
             do (&read_mode).read |state| {
                 // complete handshake with other readers
-                for vec::each_ref(reader_convos) |x| {
-                    match *x {
+                for vec::each(reader_convos) |x| {
+                    match x {
                         (_, rp) => rp.recv(),
                     }
                 }
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
index 788802ed58c..36492834c2a 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_ref(names) |nm| {
+            for vec::each(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_ref(names) |nm| {
-        match find_opt(mm.opts, mkname(*nm)) {
+    for vec::each(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_ref(names) |nm| {
-        match opt_val(mm, *nm) {
+    for vec::each(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_ref(opt_vals(mm, nm)) |v| {
-        match *v { Val(s) => vec::push(acc, s), _ => () }
+    for vec::each(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 88b46f490ac..b269ca84104 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 = ~"\"";
-    for str::chars_each(s) |c| {
+    do str::chars_iter(s) |c| {
         match c {
           '"' => escaped += ~"\\\"",
           '\\' => escaped += ~"\\\\",
@@ -834,8 +834,8 @@ mod tests {
     fn mk_dict(items: &[(~str, Json)]) -> Json {
         let d = map::str_hash();
 
-        for vec::each_ref(items) |item| {
-            let (key, value) = copy *item;
+        do vec::iter(items) |item| {
+            let (key, value) = copy item;
             d.insert(key, value);
         };
 
diff --git a/src/libstd/map.rs b/src/libstd/map.rs
index 4b41b81d4e5..1726e1f581f 100644
--- a/src/libstd/map.rs
+++ b/src/libstd/map.rs
@@ -435,12 +435,9 @@ 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();
-    for vec::each_ref(items) |item| {
-        match *item {
-            (key, value) => {
-                map.insert(key, value);
-            }
-        }
+    do vec::iter(items) |item| {
+        let (key, value) = item;
+        map.insert(key, value);
     }
     map
 }
diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs
index 13442994b65..4e23e3a1592 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_ref(results) |r| {
-            let ipv_prefix = match *r {
+        for vec::each(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 72b3c747e35..64254d5b2e5 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)) {
-        for vec::eachi(v) |i,e| {
+        do vec::iteri(v) |i,e| {
             do s.emit_vec_elt(i) {
                 f(e)
             }
diff --git a/src/libstd/sha1.rs b/src/libstd/sha1.rs
index fc34ca0cd10..9808b15dc66 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_ref(msg) |element| {
-            st.msg_block[st.msg_block_idx] = *element;
+        for vec::each(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,9 +240,7 @@ fn sha1() -> Sha1 {
         fn result_str() -> ~str {
             let rr = mk_result(&self);
             let mut s = ~"";
-            for vec::each_ref(rr) |b| {
-                s += uint::to_str(*b as uint, 16u);
-            }
+            for vec::each(rr) |b| { s += uint::to_str(b as uint, 16u); }
             return s;
         }
     }
@@ -331,7 +329,7 @@ mod tests {
         // Test that it works when accepting the message all at once
 
         let sh = sha1::sha1();
-        for vec::each_ref(tests) |t| {
+        for vec::each(tests) |t| {
             sh.input_str(t.input);
             let out = sh.result();
             check_vec_eq(t.output, out);
@@ -340,7 +338,7 @@ mod tests {
 
 
         // Test that it works when accepting the message in pieces
-        for vec::each_ref(tests) |t| {
+        for vec::each(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 97bc1b0a115..74ee337f5b5 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_ref(pairs) |p| {
-            let (a, b) = *p;
+        for vec::each(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 53d41bce977..f5528f7a79c 100644
--- a/src/libstd/sync.rs
+++ b/src/libstd/sync.rs
@@ -941,7 +941,7 @@ mod tests {
                     }
                 }
             }
-            for vec::each_ref(sibling_convos) |p| {
+            for vec::each(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_ref(p.recv()) |p| { p.recv(); } // wait on all its siblings
+        for vec::each(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 6af6a5181ec..34244e95c0c 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_ref(supported_terms) |term| {
-                if *term == env { return true; }
+            for vec::each(supported_terms) |term| {
+                if term == env { return true; }
             }
             false
           }
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index 3d4549dd423..76b6310c853 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_ref(failures) |name| {
-        st.out.write_line(fmt!("    %s", *name));
+    for vec::each(failures) |name| {
+        st.out.write_line(fmt!("    %s", name));
     }
 }
 
@@ -535,34 +535,30 @@ mod tests {
              ~"test::sort_tests"];
         let 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 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 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_ref(pairs) |p| {
-            match *p {
-                (a, b) => { assert (a == b.name); }
-            }
-        }
-    }
+    for vec::each(pairs) |p| { let (a, b) = copy p; assert (a == b.name); }
+}
 }
 
 
diff --git a/src/libstd/time.rs b/src/libstd/time.rs
index df3534fdf86..84d4e49ef90 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,11 +1031,9 @@ mod tests {
             ~"Thursday",
             ~"Friday",
             ~"Saturday"
-        ]) |day| {
-            assert test(*day, ~"%A");
-        }
+        ]/_.iter(|day| assert test(day, ~"%A"));
 
-        for vec::each_ref([
+        [
             ~"Sun",
             ~"Mon",
             ~"Tue",
@@ -1043,11 +1041,9 @@ mod tests {
             ~"Thu",
             ~"Fri",
             ~"Sat"
-        ]) |day| {
-            assert test(*day, ~"%a");
-        }
+        ]/_.iter(|day| assert test(day, ~"%a"));
 
-        for vec::each_ref([
+        [
             ~"January",
             ~"February",
             ~"March",
@@ -1060,11 +1056,9 @@ mod tests {
             ~"October",
             ~"November",
             ~"December"
-        ]) |day| {
-            assert test(*day, ~"%B");
-        }
+        ]/_.iter(|day| assert test(day, ~"%B"));
 
-        for vec::each_ref([
+        [
             ~"Jan",
             ~"Feb",
             ~"Mar",
@@ -1077,9 +1071,7 @@ mod tests {
             ~"Oct",
             ~"Nov",
             ~"Dec"
-        ]) |day| {
-            assert test(*day, ~"%b");
-        }
+        ]/_.iter(|day| assert test(day, ~"%b"));
 
         assert test(~"19", ~"%C");
         assert test(~"Fri Feb 13 23:31:30 2009", ~"%c");