Demoding in iter: any, all, map_to_vec, flat_map_to_vec, filter_to_vec

3 files changed, 29 insertions, 29 deletions

diff --git a/src/libcore/iter-trait.rs b/src/libcore/iter-trait.rs
index 4cf2002adaa..98fd0e27e97 100644
--- a/src/libcore/iter-trait.rs
+++ b/src/libcore/iter-trait.rs
@@ -14,8 +14,8 @@ impl<A> IMPL_T<A>: iter::BaseIter<A> {
 
 impl<A> IMPL_T<A>: iter::ExtendedIter<A> {
     pure fn eachi(blk: fn(uint, v: &A) -> bool) { iter::eachi(&self, blk) }
-    pure fn all(blk: fn(A) -> bool) -> bool { iter::all(self, blk) }
-    pure fn any(blk: fn(A) -> bool) -> bool { iter::any(self, blk) }
+    pure fn all(blk: fn(&A) -> bool) -> bool { iter::all(&self, blk) }
+    pure fn any(blk: fn(&A) -> bool) -> bool { iter::any(&self, blk) }
     pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B {
         iter::foldl(self, move b0, blk)
     }
@@ -30,18 +30,18 @@ impl<A: Eq> IMPL_T<A>: iter::EqIter<A> {
 }
 
 impl<A: Copy> IMPL_T<A>: iter::CopyableIter<A> {
-    pure fn filter_to_vec(pred: fn(A) -> bool) -> ~[A] {
-        iter::filter_to_vec(self, pred)
+    pure fn filter_to_vec(pred: fn(+a: A) -> bool) -> ~[A] {
+        iter::filter_to_vec(&self, pred)
     }
-    pure fn map_to_vec<B>(op: fn(v: &A) -> B) -> ~[B] {
-        iter::map_to_vec(self, op)
+    pure fn map_to_vec<B>(op: fn(+v: A) -> B) -> ~[B] {
+        iter::map_to_vec(&self, op)
     }
     pure fn to_vec() -> ~[A] { iter::to_vec(self) }
 
-    // FIXME--bug in resolve prevents this from working (#2611)
-    // fn flat_map_to_vec<B:copy,IB:base_iter<B>>(op: fn(A) -> IB) -> ~[B] {
-    //     iter::flat_map_to_vec(self, op)
-    // }
+    pure fn flat_map_to_vec<B:Copy,IB:BaseIter<B>>(op: fn(+a: A) -> IB)
+        -> ~[B] {
+        iter::flat_map_to_vec(&self, op)
+    }
 
     pure fn find(p: fn(A) -> bool) -> Option<A> { iter::find(self, p) }
 }
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index b03a0415145..2db68107fc3 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -16,8 +16,8 @@ trait BaseIter<A> {
 
 trait ExtendedIter<A> {
     pure fn eachi(blk: fn(uint, v: &A) -> bool);
-    pure fn all(blk: fn(A) -> bool) -> bool;
-    pure fn any(blk: fn(A) -> bool) -> bool;
+    pure fn all(blk: fn(&A) -> bool) -> bool;
+    pure fn any(blk: fn(&A) -> bool) -> bool;
     pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B;
     pure fn position(f: fn(A) -> bool) -> Option<uint>;
 }
@@ -35,8 +35,8 @@ trait TimesIx{
 }
 
 trait CopyableIter<A:Copy> {
-    pure fn filter_to_vec(pred: fn(A) -> bool) -> ~[A];
-    pure fn map_to_vec<B>(op: fn(v: &A) -> B) -> ~[B];
+    pure fn filter_to_vec(pred: fn(+a: A) -> bool) -> ~[A];
+    pure fn map_to_vec<B>(op: fn(+v: A) -> B) -> ~[B];
     pure fn to_vec() -> ~[A];
     pure fn find(p: fn(A) -> bool) -> Option<A>;
 }
@@ -74,22 +74,22 @@ pure fn eachi<A,IA:BaseIter<A>>(self: &IA, blk: fn(uint, v: &A) -> bool) {
     }
 }
 
-pure fn all<A,IA:BaseIter<A>>(self: IA, blk: fn(A) -> bool) -> bool {
+pure fn all<A,IA:BaseIter<A>>(self: &IA, blk: fn(&A) -> bool) -> bool {
     for self.each |a| {
-        if !blk(*a) { return false; }
+        if !blk(a) { return false; }
     }
     return true;
 }
 
-pure fn any<A,IA:BaseIter<A>>(self: IA, blk: fn(A) -> bool) -> bool {
+pure fn any<A,IA:BaseIter<A>>(self: &IA, blk: fn(&A) -> bool) -> bool {
     for self.each |a| {
-        if blk(*a) { return true; }
+        if blk(a) { return true; }
     }
     return false;
 }
 
-pure fn filter_to_vec<A:Copy,IA:BaseIter<A>>(self: IA,
-                                         prd: fn(A) -> bool) -> ~[A] {
+pure fn filter_to_vec<A:Copy,IA:BaseIter<A>>(self: &IA,
+                                         prd: fn(+a: A) -> bool) -> ~[A] {
     do vec::build_sized_opt(self.size_hint()) |push| {
         for self.each |a| {
             if prd(*a) { push(*a); }
@@ -97,17 +97,17 @@ pure fn filter_to_vec<A:Copy,IA:BaseIter<A>>(self: IA,
     }
 }
 
-pure fn map_to_vec<A:Copy,B,IA:BaseIter<A>>(self: IA, op: fn(v: &A) -> B)
+pure fn map_to_vec<A:Copy,B,IA:BaseIter<A>>(self: &IA, op: fn(+v: A) -> B)
     -> ~[B] {
     do vec::build_sized_opt(self.size_hint()) |push| {
         for self.each |a| {
-            push(op(a));
+            push(op(*a));
         }
     }
 }
 
 pure fn flat_map_to_vec<A:Copy,B:Copy,IA:BaseIter<A>,IB:BaseIter<B>>(
-    self: IA, op: fn(A) -> IB) -> ~[B] {
+    self: &IA, op: fn(+a: A) -> IB) -> ~[B] {
 
     do vec::build |push| {
         for self.each |a| {
diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
index aba511f0a7f..7c1c2f2d805 100644
--- a/src/libcore/vec.rs
+++ b/src/libcore/vec.rs
@@ -1991,8 +1991,8 @@ impl<A> &[A]: iter::BaseIter<A> {
 
 impl<A> &[A]: iter::ExtendedIter<A> {
     pure fn eachi(blk: fn(uint, v: &A) -> bool) { iter::eachi(&self, blk) }
-    pure fn all(blk: fn(A) -> bool) -> bool { iter::all(self, blk) }
-    pure fn any(blk: fn(A) -> bool) -> bool { iter::any(self, blk) }
+    pure fn all(blk: fn(&A) -> bool) -> bool { iter::all(&self, blk) }
+    pure fn any(blk: fn(&A) -> bool) -> bool { iter::any(&self, blk) }
     pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B {
         iter::foldl(self, move b0, blk)
     }
@@ -2007,11 +2007,11 @@ impl<A: Eq> &[A]: iter::EqIter<A> {
 }
 
 impl<A: Copy> &[A]: iter::CopyableIter<A> {
-    pure fn filter_to_vec(pred: fn(A) -> bool) -> ~[A] {
-        iter::filter_to_vec(self, pred)
+    pure fn filter_to_vec(pred: fn(+a: A) -> bool) -> ~[A] {
+        iter::filter_to_vec(&self, pred)
     }
-    pure fn map_to_vec<B>(op: fn(v: &A) -> B) -> ~[B] {
-        iter::map_to_vec(self, op)
+    pure fn map_to_vec<B>(op: fn(+v: A) -> B) -> ~[B] {
+        iter::map_to_vec(&self, op)
     }
     pure fn to_vec() -> ~[A] { iter::to_vec(self) }