auto merge of #7055 : thestinger/rust/iterator, r=catamorphism

This was a lot more painful than just changing `x.each` to `x.iter().advance` . I ran into my old friend #5898 and had to add underscores to some method names as a temporary workaround.

The borrow checker also had other ideas because rvalues aren't handled very well yet so temporary variables had to be added. However, storing the temporary in a variable led to dynamic `@mut` failures, so those had to be wrapped in blocks except where the scope ends immediately.

Anyway, the ugliness will be fixed as the compiler issues are fixed and this change will amount to `for x.each |x|` becoming `for x.iter |x|` and making all the iterator adaptors available.

I dropped the run-pass tests for `old_iter` because there's not much point in fixing a module that's on the way out in the next week or so.

2 files changed, 14 insertions, 13 deletions

diff --git a/src/libextra/par.rs b/src/libextra/par.rs
index 23b7cdc0997..05fe4ed72ee 100644
--- a/src/libextra/par.rs
+++ b/src/libextra/par.rs
@@ -139,8 +139,8 @@ pub fn any<A:Copy + Owned>(
     fn_factory: &fn() -> ~fn(&A) -> bool) -> bool {
     let mapped = map_slices(xs, || {
         let f = fn_factory();
-        let result: ~fn(uint, &[A]) -> bool = |_, slice| slice.iter().any(f);
+        let result: ~fn(uint, &[A]) -> bool = |_, slice| slice.iter().any_(f);
         result
     });
-    mapped.iter().any(|&x| x)
+    mapped.iter().any_(|&x| x)
 }
diff --git a/src/libextra/treemap.rs b/src/libextra/treemap.rs
index 9db3d48a3b8..3f74b905f2a 100644
--- a/src/libextra/treemap.rs
+++ b/src/libextra/treemap.rs
@@ -427,7 +427,7 @@ impl<T: TotalOrd> Set<T> for TreeSet<T> {
                 b = y.next();
             }
         }
-        return b.each(|&x| f(x)) && y.advance(f);
+        b.iter().advance(|&x| f(x)) && y.advance(f)
     }
 
     /// Visit the values (in-order) representing the intersection
@@ -485,7 +485,7 @@ impl<T: TotalOrd> Set<T> for TreeSet<T> {
                 a = x.next();
             }
         }
-        return b.each(|&x| f(x)) && y.advance(f);
+        b.iter().advance(|&x| f(x)) && y.advance(f)
     }
 }
 
@@ -527,14 +527,14 @@ impl<K: TotalOrd, V> TreeNode<K, V> {
 
 fn each<'r, K: TotalOrd, V>(node: &'r Option<~TreeNode<K, V>>,
                             f: &fn(&'r K, &'r V) -> bool) -> bool {
-    node.each(|x| each(&x.left, f) && f(&x.key, &x.value) &&
-                  each(&x.right, f))
+    node.iter().advance(|x| each(&x.left, f) && f(&x.key, &x.value) &&
+                            each(&x.right, f))
 }
 
 fn each_reverse<'r, K: TotalOrd, V>(node: &'r Option<~TreeNode<K, V>>,
                                     f: &fn(&'r K, &'r V) -> bool) -> bool {
-    node.each(|x| each_reverse(&x.right, f) && f(&x.key, &x.value) &&
-                  each_reverse(&x.left, f))
+    node.iter().advance(|x| each_reverse(&x.right, f) && f(&x.key, &x.value) &&
+                            each_reverse(&x.left, f))
 }
 
 fn mutate_values<'r, K: TotalOrd, V>(node: &'r mut Option<~TreeNode<K, V>>,
@@ -625,7 +625,7 @@ fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
     fn heir_swap<K: TotalOrd, V>(node: &mut ~TreeNode<K, V>,
                                  child: &mut Option<~TreeNode<K, V>>) {
         // *could* be done without recursion, but it won't borrow check
-        for child.each_mut |x| {
+        for child.mut_iter().advance |x| {
             if x.right.is_some() {
                 heir_swap(node, &mut x.right);
             } else {
@@ -680,18 +680,18 @@ fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
                 save.level -= 1;
 
                 if right_level > save.level {
-                    for save.right.each_mut |x| { x.level = save.level }
+                    for save.right.mut_iter().advance |x| { x.level = save.level }
                 }
 
                 skew(save);
 
-                for save.right.each_mut |right| {
+                for save.right.mut_iter().advance |right| {
                     skew(right);
-                    for right.right.each_mut |x| { skew(x) }
+                    for right.right.mut_iter().advance |x| { skew(x) }
                 }
 
                 split(save);
-                for save.right.each_mut |x| { split(x) }
+                for save.right.mut_iter().advance |x| { split(x) }
             }
 
             return ret;
@@ -1111,6 +1111,7 @@ mod test_set {
 
         let mut n = 0;
         for m.each |x| {
+            println(fmt!("%?", x));
             assert_eq!(*x, n);
             n += 1
         }