auto merge of #5212 : thestinger/rust/iter, r=graydon

A small step towards fixing #2827

src/test/run-pass/iter-all.rs

@@ -15,7 +15,7 @@ pub fn main() {
     assert [2u, 4u].all(is_even);
     assert [].all(is_even);
 
-    assert !Some(1u).all(is_even);
-    assert Some(2u).all(is_even);
-    assert None.all(is_even);
+    assert !iter::all(&Some(1u), is_even);
+    assert iter::all(&Some(2u), is_even);
+    assert iter::all(&None::<uint>, is_even);
 }

src/test/run-pass/iter-any.rs

@@ -15,7 +15,7 @@ pub fn main() {
     assert [1u, 2u].any(is_even);
     assert ![].any(is_even);
 
-    assert !Some(1).any(is_even);
-    assert Some(2).any(is_even);
-    assert !None.any(is_even);
+    assert !iter::any(&Some(1u), is_even);
+    assert iter::any(&Some(2u), is_even);
+    assert !iter::any(&None::<uint>, is_even);
 }

src/test/run-pass/iter-contains.rs

@@ -14,7 +14,7 @@ pub fn main() {
     assert [22u, 1u, 3u].contains(&22u) == true;
     assert [1u, 22u, 3u].contains(&22u) == true;
     assert [1u, 3u, 22u].contains(&22u) == true;
-    assert None.contains(&22u) == false;
-    assert Some(1u).contains(&22u) == false;
-    assert Some(22u).contains(&22u) == true;
+    assert iter::contains(&None::<uint>, &22u) == false;
+    assert iter::contains(&Some(1u), &22u) == false;
+    assert iter::contains(&Some(22u), &22u) == true;
 }

src/test/run-pass/iter-count.rs

@@ -13,7 +13,7 @@ pub fn main() {
     assert [1u, 3u].count(&22u) == 0u;
     assert [22u, 1u, 3u].count(&22u) == 1u;
     assert [22u, 1u, 22u].count(&22u) == 2u;
-    assert None.count(&22u) == 0u;
-    assert Some(1u).count(&22u) == 0u;
-    assert Some(22u).count(&22u) == 1u;
+    assert iter::count(&None::<uint>, &22u) == 0u;
+    assert iter::count(&Some(1u), &22u) == 0u;
+    assert iter::count(&Some(22u), &22u) == 1u;
 }

src/test/run-pass/iter-eachi.rs

@@ -16,13 +16,12 @@ pub fn main() {
     }
     assert c == 5u;
 
-    for None::<uint>.eachi |i, v| { fail!(); }
+    for iter::eachi(&None::<uint>) |i, v| { fail!(); }
 
     let mut c = 0u;
-    for Some(1u).eachi |i, v| {
+    for iter::eachi(&Some(1u)) |i, v| {
         assert (i + 1u) == *v;
         c += 1u;
     }
     assert c == 1u;
-
 }

src/test/run-pass/iter-filter-to-vec.rs

@@ -13,7 +13,7 @@ fn is_even(x: &uint) -> bool { (*x % 2) == 0 }
 pub fn main() {
     assert [1, 3].filter_to_vec(is_even) == ~[];
     assert [1, 2, 3].filter_to_vec(is_even) == ~[2];
-    assert None.filter_to_vec(is_even) == ~[];
-    assert Some(1).filter_to_vec(is_even) == ~[];
-    assert Some(2).filter_to_vec(is_even) == ~[2];
+    assert iter::filter_to_vec(&None::<uint>, is_even) == ~[];
+    assert iter::filter_to_vec(&Some(1u), is_even) == ~[];
+    assert iter::filter_to_vec(&Some(2u), is_even) == ~[2];
 }

src/test/run-pass/iter-flat-map-to-vec.rs

@@ -17,13 +17,13 @@ fn incd_if_even(x: &uint) -> Option<uint> {
 pub fn main() {
     assert (~[1u, 3u]).flat_map_to_vec(repeat) == ~[1u, 1u, 3u, 3u];
     assert (~[]).flat_map_to_vec(repeat) == ~[];
-    assert None.flat_map_to_vec(repeat) == ~[];
-    assert Some(1u).flat_map_to_vec(repeat) == ~[1u, 1u];
-    assert Some(2u).flat_map_to_vec(repeat) == ~[2u, 2u];
+    assert iter::flat_map_to_vec(&None::<uint>, repeat) == ~[];
+    assert iter::flat_map_to_vec(&Some(1u), repeat) == ~[1u, 1u];
+    assert iter::flat_map_to_vec(&Some(2u), repeat) == ~[2u, 2u];
 
     assert (~[1u, 2u, 5u]).flat_map_to_vec(incd_if_even) == ~[3u];
     assert (~[]).flat_map_to_vec(incd_if_even) == ~[];
-    assert None.flat_map_to_vec(incd_if_even) == ~[];
-    assert Some(1u).flat_map_to_vec(incd_if_even) == ~[];
-    assert Some(2u).flat_map_to_vec(incd_if_even) == ~[3u];
+    assert iter::flat_map_to_vec(&None::<uint>, incd_if_even) == ~[];
+    assert iter::flat_map_to_vec(&Some(1u), incd_if_even) == ~[];
+    assert iter::flat_map_to_vec(&Some(2u), incd_if_even) == ~[3u];
 }

src/test/run-pass/iter-foldl.rs

@@ -13,7 +13,7 @@ fn add(x: &float, y: &uint) -> float { *x + ((*y) as float) }
 pub fn main() {
     assert [1u, 3u].foldl(20f, add) == 24f;
     assert [].foldl(20f, add) == 20f;
-    assert None.foldl(20f, add) == 20f;
-    assert Some(1u).foldl(20f, add) == 21f;
-    assert Some(2u).foldl(20f, add) == 22f;
+    assert iter::foldl(&None::<uint>, 20f, add) == 20f;
+    assert iter::foldl(&Some(1u), 20f, add) == 21f;
+    assert iter::foldl(&Some(2u), 20f, add) == 22f;
 }

src/test/run-pass/iter-map-to-vec.rs

@@ -13,7 +13,7 @@ fn inc(x: &uint) -> uint { *x + 1 }
 pub fn main() {
     assert [1, 3].map_to_vec(inc) == ~[2, 4];
     assert [1, 2, 3].map_to_vec(inc) == ~[2, 3, 4];
-    assert None.map_to_vec(inc) == ~[];
-    assert Some(1).map_to_vec(inc) == ~[2];
-    assert Some(2).map_to_vec(inc) == ~[3];
+    assert iter::map_to_vec(&None::<uint>, inc) == ~[];
+    assert iter::map_to_vec(&Some(1u), inc) == ~[2];
+    assert iter::map_to_vec(&Some(2u), inc) == ~[3];
 }

src/test/run-pass/iter-min-max.rs

@@ -13,9 +13,9 @@ fn is_even(&&x: uint) -> bool { (x % 2u) == 0u }
 pub fn main() {
     assert [1u, 3u].min() == 1u;
     assert [3u, 1u].min() == 1u;
-    assert Some(1u).min() == 1u;
+    assert iter::min(&Some(1u)) == 1u;
 
     assert [1u, 3u].max() == 3u;
     assert [3u, 1u].max() == 3u;
-    assert Some(3u).max() == 3u;
+    assert iter::max(&Some(3u)) == 3u;
 }

src/test/run-pass/iter-to-vec.rs

@@ -12,7 +12,7 @@ pub fn main() {
     assert [1u, 3u].to_vec() == ~[1u, 3u];
     let e: ~[uint] = ~[];
     assert e.to_vec() == ~[];
-    assert None::<uint>.to_vec() == ~[];
-    assert Some(1u).to_vec() == ~[1u];
-    assert Some(2u).to_vec() == ~[2u];
+    assert iter::to_vec(&None::<uint>) == ~[];
+    assert iter::to_vec(&Some(1u)) == ~[1u];
+    assert iter::to_vec(&Some(2u)) == ~[2u];
 }