auto merge of #7110 : thestinger/rust/iterator, r=brson

5 files changed, 6 insertions, 140 deletions

diff --git a/src/libstd/iter.rs b/src/libstd/iter.rs
index 4886588bb94..2197feea452 100644
--- a/src/libstd/iter.rs
+++ b/src/libstd/iter.rs
@@ -24,8 +24,6 @@ An external iterator object implementing the interface in the `iterator` module
 internal iterator by calling the `advance` method. For example:
 
 ~~~ {.rust}
-use core::iterator::*;
-
 let xs = [0u, 1, 2, 3, 4, 5];
 let ys = [30, 40, 50, 60];
 let mut it = xs.iter().chain(ys.iter());
diff --git a/src/libstd/iterator.rs b/src/libstd/iterator.rs
index eedabadf74c..e65904a6899 100644
--- a/src/libstd/iterator.rs
+++ b/src/libstd/iterator.rs
@@ -45,8 +45,6 @@ pub trait IteratorUtil<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
-    /// use std::iterator::*;
-    ///
     /// let a = [0];
     /// let b = [1];
     /// let mut it = a.iter().chain_(b.iter());
@@ -64,8 +62,6 @@ pub trait IteratorUtil<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
-    /// use std::iterator::*;
-    ///
     /// let a = [0];
     /// let b = [1];
     /// let mut it = a.iter().zip(b.iter());
@@ -82,8 +78,6 @@ pub trait IteratorUtil<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
-    /// use std::iterator::*;
-    ///
     /// let a = [1, 2];
     /// let mut it = a.iter().transform(|&x| 2 * x);
     /// assert_eq!(it.next().get(), 2);
@@ -99,8 +93,6 @@ pub trait IteratorUtil<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
-    /// use std::iterator::*;
-    ///
     /// let a = [1, 2];
     /// let mut it = a.iter().filter(|&x| *x > 1);
     /// assert_eq!(it.next().get(), &2);
@@ -115,8 +107,6 @@ pub trait IteratorUtil<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
-    /// use std::iterator::*;
-    ///
     /// let a = [1, 2];
     /// let mut it = a.iter().filter_map(|&x| if x > 1 {Some(2 * x)} else {None});
     /// assert_eq!(it.next().get(), 4);
@@ -130,8 +120,6 @@ pub trait IteratorUtil<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
-    /// use std::iterator::*;
-    ///
     /// let a = [100, 200];
     /// let mut it = a.iter().enumerate();
     /// assert_eq!(it.next().get(), (0, &100));
@@ -147,8 +135,6 @@ pub trait IteratorUtil<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
-    /// use std::iterator::*;
-    ///
     /// let a = [1, 2, 3, 2, 1];
     /// let mut it = a.iter().skip_while(|&a| *a < 3);
     /// assert_eq!(it.next().get(), &3);
@@ -165,8 +151,6 @@ pub trait IteratorUtil<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
-    /// use std::iterator::*;
-    ///
     /// let a = [1, 2, 3, 2, 1];
     /// let mut it = a.iter().take_while(|&a| *a < 3);
     /// assert_eq!(it.next().get(), &1);
@@ -181,8 +165,6 @@ pub trait IteratorUtil<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
-    /// use std::iterator::*;
-    ///
     /// let a = [1, 2, 3, 4, 5];
     /// let mut it = a.iter().skip(3);
     /// assert_eq!(it.next().get(), &4);
@@ -198,8 +180,6 @@ pub trait IteratorUtil<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
-    /// use std::iterator::*;
-    ///
     /// let a = [1, 2, 3, 4, 5];
     /// let mut it = a.iter().take_(3);
     /// assert_eq!(it.next().get(), &1);
@@ -217,8 +197,6 @@ pub trait IteratorUtil<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
-    /// use std::iterator::*;
-    ///
     /// let a = [1, 2, 3, 4, 5];
     /// let mut it = a.iter().scan(1, |fac, &x| {
     ///   *fac = *fac * x;
@@ -239,6 +217,8 @@ pub trait IteratorUtil<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
+    /// use std::iterator::Counter;
+    ///
     /// for Counter::new(0, 10).advance |i| {
     ///     io::println(fmt!("%d", i));
     /// }
@@ -251,8 +231,6 @@ pub trait IteratorUtil<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
-    /// use std::iterator::*;
-    ///
     /// let a = [1, 2, 3, 4, 5];
     /// let b: ~[int] = a.iter().transform(|&x| x).collect();
     /// assert!(a == b);
@@ -265,8 +243,6 @@ pub trait IteratorUtil<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
-    /// use std::iterator::*;
-    ///
     /// let a = [1, 2, 3, 4, 5];
     /// let mut it = a.iter();
     /// assert!(it.nth(2).get() == &3);
@@ -280,8 +256,6 @@ pub trait IteratorUtil<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
-    /// use std::iterator::*;
-    ///
     /// let a = [1, 2, 3, 4, 5];
     /// assert!(a.iter().last().get() == &5);
     /// ~~~
@@ -294,8 +268,6 @@ pub trait IteratorUtil<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
-    /// use std::iterator::*;
-    ///
     /// let a = [1, 2, 3, 4, 5];
     /// assert!(a.iter().fold(0, |a, &b| a + b) == 15);
     /// ~~~
@@ -306,8 +278,6 @@ pub trait IteratorUtil<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
-    /// use std::iterator::*;
-    ///
     /// let a = [1, 2, 3, 4, 5];
     /// let mut it = a.iter();
     /// assert!(it.count() == 5);
@@ -320,8 +290,6 @@ pub trait IteratorUtil<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
-    /// use std::iterator::*;
-    ///
     /// let a = [1, 2, 3, 4, 5];
     /// assert!(a.iter().all(|&x| *x > 0));
     /// assert!(!a.iter().all(|&x| *x > 2));
@@ -334,8 +302,6 @@ pub trait IteratorUtil<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
-    /// use std::iterator::*;
-    ///
     /// let a = [1, 2, 3, 4, 5];
     /// let mut it = a.iter();
     /// assert!(it.any_(|&x| *x == 3));
@@ -482,8 +448,6 @@ pub trait AdditiveIterator<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
-    /// use std::iterator::*;
-    ///
     /// let a = [1, 2, 3, 4, 5];
     /// let mut it = a.iter().transform(|&x| x);
     /// assert!(it.sum() == 15);
@@ -504,7 +468,7 @@ pub trait MultiplicativeIterator<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
-    /// use std::iterator::*;
+    /// use std::iterator::Counter;
     ///
     /// fn factorial(n: uint) -> uint {
     ///     Counter::new(1u, 1).take_while(|&i| i <= n).product()
@@ -529,8 +493,6 @@ pub trait OrdIterator<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
-    /// use std::iterator::*;
-    ///
     /// let a = [1, 2, 3, 4, 5];
     /// assert!(a.iter().max().get() == &5);
     /// ~~~
@@ -541,8 +503,6 @@ pub trait OrdIterator<A> {
     /// # Example
     ///
     /// ~~~ {.rust}
-    /// use std::iterator::*;
-    ///
     /// let a = [1, 2, 3, 4, 5];
     /// assert!(a.iter().min().get() == &1);
     /// ~~~
diff --git a/src/libstd/old_iter.rs b/src/libstd/old_iter.rs
index 22ca356fa9b..9fea4376816 100644
--- a/src/libstd/old_iter.rs
+++ b/src/libstd/old_iter.rs
@@ -33,10 +33,6 @@ pub trait ReverseIter<A>: BaseIter<A> {
     fn each_reverse(&self, blk: &fn(&A) -> bool) -> bool;
 }
 
-pub trait MutableIter<A>: BaseIter<A> {
-    fn each_mut(&mut self, blk: &fn(&mut A) -> bool) -> bool;
-}
-
 pub trait ExtendedIter<A> {
     fn eachi(&self, blk: &fn(uint, v: &A) -> bool) -> bool;
     fn all(&self, blk: &fn(&A) -> bool) -> bool;
@@ -47,10 +43,6 @@ pub trait ExtendedIter<A> {
     fn flat_map_to_vec<B,IB: BaseIter<B>>(&self, op: &fn(&A) -> IB) -> ~[B];
 }
 
-pub trait ExtendedMutableIter<A> {
-    fn eachi_mut(&mut self, blk: &fn(uint, &mut A) -> bool) -> bool;
-}
-
 pub trait EqIter<A:Eq> {
     fn contains(&self, x: &A) -> bool;
     fn count(&self, x: &A) -> uint;
@@ -67,13 +59,6 @@ pub trait CopyableOrderedIter<A:Copy + Ord> {
     fn max(&self) -> A;
 }
 
-pub trait CopyableNonstrictIter<A:Copy> {
-    // Like "each", but copies out the value. If the receiver is mutated while
-    // iterating over it, the semantics must not be memory-unsafe but are
-    // otherwise undefined.
-    fn each_val(&const self, f: &fn(A) -> bool) -> bool;
-}
-
 // A trait for sequences that can be built by imperatively pushing elements
 // onto them.
 pub trait Buildable<A> {
diff --git a/src/libstd/prelude.rs b/src/libstd/prelude.rs
index 4400cb5de98..61b8d36266e 100644
--- a/src/libstd/prelude.rs
+++ b/src/libstd/prelude.rs
@@ -46,12 +46,10 @@ pub use cmp::{Eq, ApproxEq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Great
 pub use char::Char;
 pub use container::{Container, Mutable, Map, Set};
 pub use hash::Hash;
-pub use old_iter::{BaseIter, ReverseIter, MutableIter, ExtendedIter, EqIter};
-pub use old_iter::{CopyableIter, CopyableOrderedIter, CopyableNonstrictIter};
-pub use old_iter::{ExtendedMutableIter};
+pub use old_iter::{BaseIter, ReverseIter, ExtendedIter, EqIter};
+pub use old_iter::{CopyableIter, CopyableOrderedIter};
 pub use iter::{Times, FromIter};
-// FIXME: #5898 pub use iterator::{Iterator, IteratorUtil};
-pub use iterator::Iterator;
+pub use iterator::{Iterator, IteratorUtil};
 pub use num::{Num, NumCast};
 pub use num::{Orderable, Signed, Unsigned, Round};
 pub use num::{Algebraic, Trigonometric, Exponential, Hyperbolic};
diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
index 19233c53348..91e94f7dcf8 100644
--- a/src/libstd/vec.rs
+++ b/src/libstd/vec.rs
@@ -2487,29 +2487,6 @@ impl<A> old_iter::BaseIter<A> for @[A] {
     fn size_hint(&self) -> Option<uint> { Some(self.len()) }
 }
 
-impl<'self,A> old_iter::MutableIter<A> for &'self mut [A] {
-    #[inline(always)]
-    fn each_mut<'a>(&'a mut self, blk: &fn(v: &'a mut A) -> bool) -> bool {
-        self.mut_iter().advance(blk)
-    }
-}
-
-// FIXME(#4148): This should be redundant
-impl<A> old_iter::MutableIter<A> for ~[A] {
-    #[inline(always)]
-    fn each_mut<'a>(&'a mut self, blk: &fn(v: &'a mut A) -> bool) -> bool {
-        self.mut_iter().advance(blk)
-    }
-}
-
-// FIXME(#4148): This should be redundant
-impl<A> old_iter::MutableIter<A> for @mut [A] {
-    #[inline(always)]
-    fn each_mut(&mut self, blk: &fn(v: &mut A) -> bool) -> bool {
-        self.mut_iter().advance(blk)
-    }
-}
-
 impl<'self,A> old_iter::ExtendedIter<A> for &'self [A] {
     pub fn eachi(&self, blk: &fn(uint, v: &A) -> bool) -> bool {
         old_iter::eachi(self, blk)
@@ -2535,13 +2512,6 @@ impl<'self,A> old_iter::ExtendedIter<A> for &'self [A] {
     }
 }
 
-impl<'self,A> old_iter::ExtendedMutableIter<A> for &'self mut [A] {
-    #[inline(always)]
-    pub fn eachi_mut(&mut self, blk: &fn(uint, v: &mut A) -> bool) -> bool {
-        self.mut_iter().enumerate().advance(|(i, v)| blk(i, v))
-    }
-}
-
 // FIXME(#4148): This should be redundant
 impl<A> old_iter::ExtendedIter<A> for ~[A] {
     pub fn eachi(&self, blk: &fn(uint, v: &A) -> bool) -> bool {
@@ -2660,41 +2630,6 @@ impl<A:Copy + Ord> old_iter::CopyableOrderedIter<A> for @[A] {
     fn max(&self) -> A { old_iter::max(self) }
 }
 
-impl<'self,A:Copy> old_iter::CopyableNonstrictIter<A> for &'self [A] {
-    fn each_val(&const self, f: &fn(A) -> bool) -> bool {
-        let mut i = 0;
-        while i < self.len() {
-            if !f(copy self[i]) { return false; }
-            i += 1;
-        }
-        return true;
-    }
-}
-
-// FIXME(#4148): This should be redundant
-impl<A:Copy> old_iter::CopyableNonstrictIter<A> for ~[A] {
-    fn each_val(&const self, f: &fn(A) -> bool) -> bool {
-        let mut i = 0;
-        while i < uniq_len(self) {
-            if !f(copy self[i]) { return false; }
-            i += 1;
-        }
-        return true;
-    }
-}
-
-// FIXME(#4148): This should be redundant
-impl<A:Copy> old_iter::CopyableNonstrictIter<A> for @[A] {
-    fn each_val(&const self, f: &fn(A) -> bool) -> bool {
-        let mut i = 0;
-        while i < self.len() {
-            if !f(copy self[i]) { return false; }
-            i += 1;
-        }
-        return true;
-    }
-}
-
 impl<A:Clone> Clone for ~[A] {
     #[inline]
     fn clone(&self) -> ~[A] {
@@ -4356,14 +4291,4 @@ mod tests {
         }
         assert_eq!(v, ~[~[1,2,3],~[1,3,2],~[2,1,3],~[2,3,1],~[3,1,2],~[3,2,1]]);
     }
-
-    #[test]
-    fn test_each_val() {
-        use old_iter::CopyableNonstrictIter;
-        let mut i = 0;
-        for [1, 2, 3].each_val |v| {
-            i += v;
-        }
-        assert_eq!(i, 6);
-    }
 }