---

yaml
---
r: 36818
b: refs/heads/try2
c: 938058b
h: refs/heads/master
v: v3

Author: erickt

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: eb8fd119c65c67f3b1b8268cc7341c22d39b7b61
 refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 97ddf3c7bdbd874ad6596e9444abb61b5903bc04
+refs/heads/try2: 938058b0040e3c482e10b78eeef7afb941b2b64e
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
 refs/heads/dist-snap: 22efa39382d41b084fde1719df7ae8ce5697d8c9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try2/src/libcore/vec.rs

@@ -2024,6 +2024,32 @@ impl<A> &[A]: iter::BaseIter<A> {
     pure fn size_hint(&self) -> Option<uint> { Some(len(*self)) }
 }
 
+// FIXME(#4148): This should be redundant
+impl<A> ~[A]: iter::BaseIter<A> {
+    pub pure fn each(&self, blk: fn(v: &A) -> bool) {
+        // FIXME(#2263)---should be able to call each(self, blk)
+        for each(*self) |e| {
+            if (!blk(e)) {
+                return;
+            }
+        }
+    }
+    pure fn size_hint(&self) -> Option<uint> { Some(len(*self)) }
+}
+
+// FIXME(#4148): This should be redundant
+impl<A> @[A]: iter::BaseIter<A> {
+    pub pure fn each(&self, blk: fn(v: &A) -> bool) {
+        // FIXME(#2263)---should be able to call each(self, blk)
+        for each(*self) |e| {
+            if (!blk(e)) {
+                return;
+            }
+        }
+    }
+    pure fn size_hint(&self) -> Option<uint> { Some(len(*self)) }
+}
+
 impl<A> &[A]: iter::ExtendedIter<A> {
     pub pure fn eachi(&self, blk: fn(uint, v: &A) -> bool) {
         iter::eachi(self, blk)
@@ -2049,11 +2075,75 @@ impl<A> &[A]: iter::ExtendedIter<A> {
     }
 }
 
+// FIXME(#4148): This should be redundant
+impl<A> ~[A]: iter::ExtendedIter<A> {
+    pub pure fn eachi(&self, blk: fn(uint, v: &A) -> bool) {
+        iter::eachi(self, blk)
+    }
+    pub pure fn all(&self, blk: fn(&A) -> bool) -> bool {
+        iter::all(self, blk)
+    }
+    pub pure fn any(&self, blk: fn(&A) -> bool) -> bool {
+        iter::any(self, blk)
+    }
+    pub pure fn foldl<B>(&self, b0: B, blk: fn(&B, &A) -> B) -> B {
+        iter::foldl(self, b0, blk)
+    }
+    pub pure fn position(&self, f: fn(&A) -> bool) -> Option<uint> {
+        iter::position(self, f)
+    }
+    pure fn map_to_vec<B>(&self, op: fn(&A) -> B) -> ~[B] {
+        iter::map_to_vec(self, op)
+    }
+    pure fn flat_map_to_vec<B,IB:BaseIter<B>>(&self, op: fn(&A) -> IB)
+        -> ~[B] {
+        iter::flat_map_to_vec(self, op)
+    }
+}
+
+// FIXME(#4148): This should be redundant
+impl<A> @[A]: iter::ExtendedIter<A> {
+    pub pure fn eachi(&self, blk: fn(uint, v: &A) -> bool) {
+        iter::eachi(self, blk)
+    }
+    pub pure fn all(&self, blk: fn(&A) -> bool) -> bool {
+        iter::all(self, blk)
+    }
+    pub pure fn any(&self, blk: fn(&A) -> bool) -> bool {
+        iter::any(self, blk)
+    }
+    pub pure fn foldl<B>(&self, b0: B, blk: fn(&B, &A) -> B) -> B {
+        iter::foldl(self, b0, blk)
+    }
+    pub pure fn position(&self, f: fn(&A) -> bool) -> Option<uint> {
+        iter::position(self, f)
+    }
+    pure fn map_to_vec<B>(&self, op: fn(&A) -> B) -> ~[B] {
+        iter::map_to_vec(self, op)
+    }
+    pure fn flat_map_to_vec<B,IB:BaseIter<B>>(&self, op: fn(&A) -> IB)
+        -> ~[B] {
+        iter::flat_map_to_vec(self, op)
+    }
+}
+
 impl<A: Eq> &[A]: iter::EqIter<A> {
     pub pure fn contains(&self, x: &A) -> bool { iter::contains(self, x) }
     pub pure fn count(&self, x: &A) -> uint { iter::count(self, x) }
 }
 
+// FIXME(#4148): This should be redundant
+impl<A: Eq> ~[A]: iter::EqIter<A> {
+    pub pure fn contains(&self, x: &A) -> bool { iter::contains(self, x) }
+    pub pure fn count(&self, x: &A) -> uint { iter::count(self, x) }
+}
+
+// FIXME(#4148): This should be redundant
+impl<A: Eq> @[A]: iter::EqIter<A> {
+    pub pure fn contains(&self, x: &A) -> bool { iter::contains(self, x) }
+    pub pure fn count(&self, x: &A) -> uint { iter::count(self, x) }
+}
+
 impl<A: Copy> &[A]: iter::CopyableIter<A> {
     pure fn filter_to_vec(&self, pred: fn(&A) -> bool) -> ~[A] {
         iter::filter_to_vec(self, pred)
@@ -2064,11 +2154,45 @@ impl<A: Copy> &[A]: iter::CopyableIter<A> {
     }
 }
 
+// FIXME(#4148): This should be redundant
+impl<A: Copy> ~[A]: iter::CopyableIter<A> {
+    pure fn filter_to_vec(&self, pred: fn(&A) -> bool) -> ~[A] {
+        iter::filter_to_vec(self, pred)
+    }
+    pure fn to_vec(&self) -> ~[A] { iter::to_vec(self) }
+    pub pure fn find(&self, f: fn(&A) -> bool) -> Option<A> {
+        iter::find(self, f)
+    }
+}
+
+// FIXME(#4148): This should be redundant
+impl<A: Copy> @[A]: iter::CopyableIter<A> {
+    pure fn filter_to_vec(&self, pred: fn(&A) -> bool) -> ~[A] {
+        iter::filter_to_vec(self, pred)
+    }
+    pure fn to_vec(&self) -> ~[A] { iter::to_vec(self) }
+    pub pure fn find(&self, f: fn(&A) -> bool) -> Option<A> {
+        iter::find(self, f)
+    }
+}
+
 impl<A: Copy Ord> &[A]: iter::CopyableOrderedIter<A> {
     pure fn min(&self) -> A { iter::min(self) }
     pure fn max(&self) -> A { iter::max(self) }
 }
 
+// FIXME(#4148): This should be redundant
+impl<A: Copy Ord> ~[A]: iter::CopyableOrderedIter<A> {
+    pure fn min(&self) -> A { iter::min(self) }
+    pure fn max(&self) -> A { iter::max(self) }
+}
+
+// FIXME(#4148): This should be redundant
+impl<A: Copy Ord> @[A]: iter::CopyableOrderedIter<A> {
+    pure fn min(&self) -> A { iter::min(self) }
+    pure fn max(&self) -> A { iter::max(self) }
+}
+
 impl<A:Copy> &[A] : iter::CopyableNonstrictIter<A> {
     pure fn each_val(&const self, f: fn(A) -> bool) {
         let mut i = 0;
@@ -2079,6 +2203,7 @@ impl<A:Copy> &[A] : iter::CopyableNonstrictIter<A> {
     }
 }
 
+// FIXME(#4148): This should be redundant
 impl<A:Copy> ~[A] : iter::CopyableNonstrictIter<A> {
     pure fn each_val(&const self, f: fn(A) -> bool) {
         let mut i = 0;
@@ -2089,6 +2214,7 @@ impl<A:Copy> ~[A] : iter::CopyableNonstrictIter<A> {
     }
 }
 
+// FIXME(#4148): This should be redundant
 impl<A:Copy> @[A] : iter::CopyableNonstrictIter<A> {
     pure fn each_val(&const self, f: fn(A) -> bool) {
         let mut i = 0;

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

@@ -8,23 +8,22 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// xfail-test -- flat_map_to_vec currently disable
-fn repeat(x: &uint) -> ~[uint] { ~[x, x] }
+fn repeat(x: &uint) -> ~[uint] { ~[*x, *x] }
 
-fn incd_if_even(x: &uint) -> option<uint> {
-    if (x % 2u) == 0u {some(x + 1u)} else {none}
+fn incd_if_even(x: &uint) -> Option<uint> {
+    if (*x % 2u) == 0u {Some(*x + 1u)} else {None}
 }
 
 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 (~[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 ~[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 (~[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];
 }