auto merge of #5369 : thestinger/rust/iter, r=z0w0

This can eventually be implemented on other sequence containers like `deque` (it's missing `each` too at the moment).

Author: bors

src/libcore/iter.rs

@@ -31,6 +31,10 @@ pub trait ReverseIter<A>: BaseIter<A> {
     pure fn each_reverse(&self, blk: &fn(&A) -> bool);
 }
 
+pub trait MutableIter<A>: BaseIter<A> {
+    fn each_mut(&mut self, blk: &fn(&mut A) -> bool);
+}
+
 pub trait ExtendedIter<A> {
     pure fn eachi(&self, blk: &fn(uint, v: &A) -> bool);
     pure fn all(&self, blk: &fn(&A) -> bool) -> bool;

src/libcore/prelude.rs

@@ -27,8 +27,9 @@ pub use clone::Clone;
 pub use cmp::{Eq, Ord, TotalOrd, Ordering, Less, Equal, Greater};
 pub use container::{Container, Mutable, Map, Set};
 pub use hash::Hash;
-pub use iter::{BaseIter, ReverseIter, ExtendedIter, EqIter, CopyableIter};
-pub use iter::{CopyableOrderedIter, CopyableNonstrictIter, Times};
+pub use iter::{BaseIter, ReverseIter, MutableIter, ExtendedIter, EqIter};
+pub use iter::{CopyableIter, CopyableOrderedIter, CopyableNonstrictIter};
+pub use iter::Times;
 pub use num::NumCast;
 pub use path::GenericPath;
 pub use path::Path;

src/libcore/vec.rs

@@ -1357,7 +1357,7 @@ pub pure fn each<T>(v: &r/[T], f: &fn(&r/T) -> bool) {
 /// a vector with mutable contents and you would like
 /// to mutate the contents as you iterate.
 #[inline(always)]
-pub fn each_mut<T>(v: &mut [T], f: &fn(elem: &mut T) -> bool) {
+pub fn each_mut<T>(v: &'r mut [T], f: &fn(elem: &'r mut T) -> bool) {
     let mut i = 0;
     let n = v.len();
     while i < n {
@@ -2280,11 +2280,9 @@ pub mod bytes {
 // ___________________________________________________________________________
 // ITERATION TRAIT METHODS
 
-impl<A> iter::BaseIter<A> for &self/[A] {
+impl<A> iter::BaseIter<A> for &'self [A] {
     #[inline(always)]
-    pub pure fn each(&self, blk: &fn(v: &'self A) -> bool) {
-        each(*self, blk)
-    }
+    pure fn each(&self, blk: &fn(v: &'self A) -> bool) { each(*self, blk) }
     #[inline(always)]
     pure fn size_hint(&self) -> Option<uint> { Some(self.len()) }
 }
@@ -2305,6 +2303,29 @@ impl<A> iter::BaseIter<A> for @[A] {
     pure fn size_hint(&self) -> Option<uint> { Some(self.len()) }
 }
 
+impl<A> iter::MutableIter<A> for &'self mut [A] {
+    #[inline(always)]
+    fn each_mut(&mut self, blk: &fn(v: &'self mut A) -> bool) {
+        each_mut(*self, blk)
+    }
+}
+
+// FIXME(#4148): This should be redundant
+impl<A> iter::MutableIter<A> for ~[A] {
+    #[inline(always)]
+    fn each_mut(&mut self, blk: &fn(v: &'self mut A) -> bool) {
+        each_mut(*self, blk)
+    }
+}
+
+// FIXME(#4148): This should be redundant
+impl<A> iter::MutableIter<A> for @mut [A] {
+    #[inline(always)]
+    fn each_mut(&mut self, blk: &fn(v: &mut A) -> bool) {
+        each_mut(*self, blk)
+    }
+}
+
 impl<A> iter::ExtendedIter<A> for &self/[A] {
     pub pure fn eachi(&self, blk: &fn(uint, v: &A) -> bool) {
         iter::eachi(self, blk)