diff options
Diffstat (limited to 'src')
59 files changed, 304 insertions, 147 deletions
diff --git a/src/libcollections/binary_heap.rs b/src/libcollections/binary_heap.rs index 8efc4cd50c1..ed931028446 100644 --- a/src/libcollections/binary_heap.rs +++ b/src/libcollections/binary_heap.rs @@ -585,10 +585,10 @@ impl<T> DoubleEndedIterator<T> for MoveItems<T> { fn next_back(&mut self) -> Option<T> { self.iter.next_back() } } -impl<T> ExactSize<T> for MoveItems<T> {} +impl<T> ExactSizeIterator<T> for MoveItems<T> {} impl<T: Ord> FromIterator<T> for BinaryHeap<T> { - fn from_iter<Iter: Iterator<T>>(mut iter: Iter) -> BinaryHeap<T> { + fn from_iter<Iter: Iterator<T>>(iter: Iter) -> BinaryHeap<T> { let vec: Vec<T> = iter.collect(); BinaryHeap::from_vec(vec) } diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs index 64abc78daf3..903a9bd9823 100644 --- a/src/libcollections/bit.rs +++ b/src/libcollections/bit.rs @@ -68,7 +68,7 @@ use core::prelude::*; use core::cmp; use core::default::Default; use core::fmt; -use core::iter::{Chain, Enumerate, Repeat, Skip, Take}; +use core::iter::{Chain, Enumerate, Repeat, Skip, Take, repeat}; use core::iter; use core::num::Int; use core::slice; @@ -88,11 +88,11 @@ fn match_words <'a,'b>(a: &'a Bitv, b: &'b Bitv) -> (MatchWords<'a>, MatchWords< // have to uselessly pretend to pad the longer one for type matching if a_len < b_len { - (a.mask_words(0).chain(Repeat::new(0u32).enumerate().take(b_len).skip(a_len)), - b.mask_words(0).chain(Repeat::new(0u32).enumerate().take(0).skip(0))) + (a.mask_words(0).chain(repeat(0u32).enumerate().take(b_len).skip(a_len)), + b.mask_words(0).chain(repeat(0u32).enumerate().take(0).skip(0))) } else { - (a.mask_words(0).chain(Repeat::new(0u32).enumerate().take(0).skip(0)), - b.mask_words(0).chain(Repeat::new(0u32).enumerate().take(a_len).skip(b_len))) + (a.mask_words(0).chain(repeat(0u32).enumerate().take(0).skip(0)), + b.mask_words(0).chain(repeat(0u32).enumerate().take(a_len).skip(b_len))) } } @@ -943,7 +943,7 @@ impl<'a> DoubleEndedIterator<bool> for Bits<'a> { } } -impl<'a> ExactSize<bool> for Bits<'a> {} +impl<'a> ExactSizeIterator<bool> for Bits<'a> {} impl<'a> RandomAccessIterator<bool> for Bits<'a> { #[inline] diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index adb9a9ae5bd..8a6d26c26bf 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -863,7 +863,7 @@ impl<K, V, E, T: Traverse<E> + DoubleEndedIterator<TraversalItem<K, V, E>>> // Note that the design of these iterators permits an *arbitrary* initial pair of min and max, // making these arbitrary sub-range iterators. However the logic to construct these paths // efficiently is fairly involved, so this is a FIXME. The sub-range iterators also wouldn't be - // able to accurately predict size, so those iterators can't implement ExactSize. + // able to accurately predict size, so those iterators can't implement ExactSizeIterator. fn next(&mut self) -> Option<(K, V)> { loop { // We want the smallest element, so try to get the top of the left stack @@ -963,7 +963,7 @@ impl<'a, K, V> Iterator<(&'a K, &'a V)> for Entries<'a, K, V> { impl<'a, K, V> DoubleEndedIterator<(&'a K, &'a V)> for Entries<'a, K, V> { fn next_back(&mut self) -> Option<(&'a K, &'a V)> { self.inner.next_back() } } -impl<'a, K, V> ExactSize<(&'a K, &'a V)> for Entries<'a, K, V> {} +impl<'a, K, V> ExactSizeIterator<(&'a K, &'a V)> for Entries<'a, K, V> {} impl<'a, K, V> Iterator<(&'a K, &'a mut V)> for MutEntries<'a, K, V> { @@ -973,7 +973,7 @@ impl<'a, K, V> Iterator<(&'a K, &'a mut V)> for MutEntries<'a, K, V> { impl<'a, K, V> DoubleEndedIterator<(&'a K, &'a mut V)> for MutEntries<'a, K, V> { fn next_back(&mut self) -> Option<(&'a K, &'a mut V)> { self.inner.next_back() } } -impl<'a, K, V> ExactSize<(&'a K, &'a mut V)> for MutEntries<'a, K, V> {} +impl<'a, K, V> ExactSizeIterator<(&'a K, &'a mut V)> for MutEntries<'a, K, V> {} impl<K, V> Iterator<(K, V)> for MoveEntries<K, V> { @@ -983,7 +983,7 @@ impl<K, V> Iterator<(K, V)> for MoveEntries<K, V> { impl<K, V> DoubleEndedIterator<(K, V)> for MoveEntries<K, V> { fn next_back(&mut self) -> Option<(K, V)> { self.inner.next_back() } } -impl<K, V> ExactSize<(K, V)> for MoveEntries<K, V> {} +impl<K, V> ExactSizeIterator<(K, V)> for MoveEntries<K, V> {} diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs index 19216b32ce7..3f95bda663e 100644 --- a/src/libcollections/dlist.rs +++ b/src/libcollections/dlist.rs @@ -607,7 +607,7 @@ impl<'a, A> DoubleEndedIterator<&'a A> for Items<'a, A> { } } -impl<'a, A> ExactSize<&'a A> for Items<'a, A> {} +impl<'a, A> ExactSizeIterator<&'a A> for Items<'a, A> {} impl<'a, A> Iterator<&'a mut A> for MutItems<'a, A> { #[inline] @@ -645,7 +645,7 @@ impl<'a, A> DoubleEndedIterator<&'a mut A> for MutItems<'a, A> { } } -impl<'a, A> ExactSize<&'a mut A> for MutItems<'a, A> {} +impl<'a, A> ExactSizeIterator<&'a mut A> for MutItems<'a, A> {} /// Allows mutating a `DList` while iterating. pub trait ListInsertion<A> { diff --git a/src/libcollections/ring_buf.rs b/src/libcollections/ring_buf.rs index 643b500ec3e..8f0b0d41b03 100644 --- a/src/libcollections/ring_buf.rs +++ b/src/libcollections/ring_buf.rs @@ -695,8 +695,7 @@ impl<'a, T> DoubleEndedIterator<&'a T> for Items<'a, T> { } } - -impl<'a, T> ExactSize<&'a T> for Items<'a, T> {} +impl<'a, T> ExactSizeIterator<&'a T> for Items<'a, T> {} impl<'a, T> RandomAccessIterator<&'a T> for Items<'a, T> { #[inline] @@ -763,7 +762,7 @@ impl<'a, T> DoubleEndedIterator<&'a mut T> for MutItems<'a, T> { } } -impl<'a, T> ExactSize<&'a mut T> for MutItems<'a, T> {} +impl<'a, T> ExactSizeIterator<&'a mut T> for MutItems<'a, T> {} impl<A: PartialEq> PartialEq for RingBuf<A> { fn eq(&self, other: &RingBuf<A>) -> bool { @@ -1322,7 +1321,7 @@ mod tests { let u: Vec<int> = deq.iter().map(|&x| x).collect(); assert_eq!(u, v); - let mut seq = iter::count(0u, 2).take(256); + let seq = iter::count(0u, 2).take(256); let deq: RingBuf<uint> = seq.collect(); for (i, &x) in deq.iter().enumerate() { assert_eq!(2*i, x); diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index ab5ac5bf9e1..06e1ee0fc0f 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -94,7 +94,7 @@ use core::cmp; use core::kinds::Sized; use core::mem::size_of; use core::mem; -use core::prelude::{Clone, Greater, Iterator, Less, None, Option}; +use core::prelude::{Clone, Greater, Iterator, IteratorExt, Less, None, Option}; use core::prelude::{Ord, Ordering, RawPtr, Some, range}; use core::ptr; use core::iter::{range_step, MultiplicativeIterator}; diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index 7b53fead6b2..ebd30d758f2 100644 --- a/src/libcollections/str.rs +++ b/src/libcollections/str.rs @@ -61,7 +61,7 @@ use core::cmp; use core::iter::AdditiveIterator; use core::kinds::Sized; use core::prelude::{Char, Clone, Eq, Equiv}; -use core::prelude::{Iterator, SlicePrelude, None, Option, Ord, Ordering}; +use core::prelude::{Iterator, IteratorExt, SlicePrelude, None, Option, Ord, Ordering}; use core::prelude::{PartialEq, PartialOrd, Result, AsSlice, Some, Tuple2}; use core::prelude::{range}; @@ -828,7 +828,7 @@ mod tests { use std::cmp::{Equal, Greater, Less, Ord, PartialOrd, Equiv}; use std::option::{Some, None}; use std::ptr::RawPtr; - use std::iter::{Iterator, DoubleEndedIterator}; + use std::iter::{Iterator, IteratorExt, DoubleEndedIteratorExt}; use super::*; use std::slice::{AsSlice, SlicePrelude}; @@ -2177,12 +2177,15 @@ mod tests { let gr_inds = s.grapheme_indices(true).rev().collect::<Vec<(uint, &str)>>(); let b: &[_] = &[(11, "\r\n"), (6, "ö̲"), (3, "é"), (0u, "a̐")]; assert_eq!(gr_inds.as_slice(), b); - let mut gr_inds = s.grapheme_indices(true); - let e1 = gr_inds.size_hint(); - assert_eq!(e1, (1, Some(13))); - let c = gr_inds.count(); - assert_eq!(c, 4); - let e2 = gr_inds.size_hint(); + let mut gr_inds_iter = s.grapheme_indices(true); + { + let gr_inds = gr_inds_iter.by_ref(); + let e1 = gr_inds.size_hint(); + assert_eq!(e1, (1, Some(13))); + let c = gr_inds.count(); + assert_eq!(c, 4); + } + let e2 = gr_inds_iter.size_hint(); assert_eq!(e2, (0, Some(0))); // make sure the reverse iterator does the right thing with "\n" at beginning of string @@ -2319,7 +2322,7 @@ mod bench { use test::Bencher; use test::black_box; use super::*; - use std::iter::{Iterator, DoubleEndedIterator}; + use std::iter::{IteratorExt, DoubleEndedIteratorExt}; use std::str::StrPrelude; use std::slice::SlicePrelude; diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index ec520a93c1e..acbb28293fd 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -1341,7 +1341,7 @@ impl<T> DoubleEndedIterator<T> for MoveItems<T> { } } -impl<T> ExactSize<T> for MoveItems<T> {} +impl<T> ExactSizeIterator<T> for MoveItems<T> {} #[unsafe_destructor] impl<T> Drop for MoveItems<T> { diff --git a/src/libcore/fmt/float.rs b/src/libcore/fmt/float.rs index 1760c4d8e66..31a46c26e2a 100644 --- a/src/libcore/fmt/float.rs +++ b/src/libcore/fmt/float.rs @@ -17,7 +17,7 @@ pub use self::SignFormat::*; use char; use char::Char; use fmt; -use iter::{range, DoubleEndedIterator}; +use iter::{range, DoubleEndedIteratorExt}; use num::{Float, FPNaN, FPInfinite, ToPrimitive}; use num::cast; use result::Ok; diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index 6e77b0a7c79..605148beb90 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -14,7 +14,7 @@ use any; use cell::{Cell, Ref, RefMut}; -use iter::{Iterator, range}; +use iter::{Iterator, IteratorExt, range}; use kinds::{Copy, Sized}; use mem; use option::{Option, Some, None}; diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs index 1c856a6e208..a441ced03b2 100644 --- a/src/libcore/fmt/num.rs +++ b/src/libcore/fmt/num.rs @@ -15,7 +15,7 @@ #![allow(unsigned_negation)] use fmt; -use iter::DoubleEndedIterator; +use iter::DoubleEndedIteratorExt; use num::{Int, cast}; use slice::SlicePrelude; diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index 02242492e34..496e7979b72 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -72,12 +72,14 @@ use uint; #[deprecated = "renamed to Extend"] pub use self::Extend as Extendable; /// Conversion from an `Iterator` +#[unstable = "may be replaced by a more general conversion trait"] pub trait FromIterator<A> { /// Build a container with elements from an external iterator. fn from_iter<T: Iterator<A>>(iterator: T) -> Self; } /// A type growable from an `Iterator` implementation +#[unstable = "just renamed as part of collections reform"] pub trait Extend<A> { /// Extend a container with the elements yielded by an arbitrary iterator fn extend<T: Iterator<A>>(&mut self, iterator: T); @@ -94,6 +96,7 @@ pub trait Extend<A> { /// it wishes, either by returning `None` infinitely, or by doing something /// else. #[lang="iterator"] +#[unstable = "just split up for object safety"] pub trait Iterator<A> { /// Advance the iterator and return the next value. Return `None` when the end is reached. fn next(&mut self) -> Option<A>; @@ -104,7 +107,11 @@ pub trait Iterator<A> { /// does not fit within a `uint`. #[inline] fn size_hint(&self) -> (uint, Option<uint>) { (0, None) } +} +#[unstable = "new convention for extension traits"] +/// An extension trait providing numerous methods applicable to all iterators. +pub trait IteratorExt<A>: Iterator<A> { /// Chain this iterator with another, returning a new iterator which will /// finish iterating over the current iterator, and then it will iterate /// over the other specified iterator. @@ -120,6 +127,7 @@ pub trait Iterator<A> { /// assert!(it.next().is_none()); /// ``` #[inline] + #[stable] fn chain<U: Iterator<A>>(self, other: U) -> Chain<Self, U> { Chain{a: self, b: other, flag: false} } @@ -140,6 +148,7 @@ pub trait Iterator<A> { /// assert!(it.next().is_none()); /// ``` #[inline] + #[stable] fn zip<B, U: Iterator<B>>(self, other: U) -> Zip<Self, U> { Zip{a: self, b: other} } @@ -157,6 +166,7 @@ pub trait Iterator<A> { /// assert!(it.next().is_none()); /// ``` #[inline] + #[unstable = "waiting for unboxed closures"] fn map<'r, B>(self, f: |A|: 'r -> B) -> Map<'r, A, B, Self> { Map{iter: self, f: f} } @@ -174,6 +184,7 @@ pub trait Iterator<A> { /// assert!(it.next().is_none()); /// ``` #[inline] + #[unstable = "waiting for unboxed closures"] fn filter<'r>(self, predicate: |&A|: 'r -> bool) -> Filter<'r, A, Self> { Filter{iter: self, predicate: predicate} } @@ -191,6 +202,7 @@ pub trait Iterator<A> { /// assert!(it.next().is_none()); /// ``` #[inline] + #[unstable = "waiting for unboxed closures"] fn filter_map<'r, B>(self, f: |A|: 'r -> Option<B>) -> FilterMap<'r, A, B, Self> { FilterMap { iter: self, f: f } } @@ -209,6 +221,7 @@ pub trait Iterator<A> { /// assert!(it.next().is_none()); /// ``` #[inline] + #[stable] fn enumerate(self) -> Enumerate<Self> { Enumerate{iter: self, count: 0} } @@ -232,6 +245,7 @@ pub trait Iterator<A> { /// assert!(it.next().is_none()); /// ``` #[inline] + #[stable] fn peekable(self) -> Peekable<A, Self> { Peekable{iter: self, peeked: None} } @@ -251,6 +265,7 @@ pub trait Iterator<A> { /// assert!(it.next().is_none()); /// ``` #[inline] + #[unstable = "waiting for unboxed closures"] fn skip_while<'r>(self, predicate: |&A|: 'r -> bool) -> SkipWhile<'r, A, Self> { SkipWhile{iter: self, flag: false, predicate: predicate} } @@ -269,6 +284,7 @@ pub trait Iterator<A> { /// assert!(it.next().is_none()); /// ``` #[inline] + #[unstable = "waiting for unboxed closures, may want to require peek"] fn take_while<'r>(self, predicate: |&A|: 'r -> bool) -> TakeWhile<'r, A, Self> { TakeWhile{iter: self, flag: false, predicate: predicate} } @@ -286,6 +302,7 @@ pub trait Iterator<A> { /// assert!(it.next().is_none()); /// ``` #[inline] + #[stable] fn skip(self, n: uint) -> Skip<Self> { Skip{iter: self, n: n} } @@ -304,6 +321,7 @@ pub trait Iterator<A> { /// assert!(it.next().is_none()); /// ``` #[inline] + #[stable] fn take(self, n: uint) -> Take<Self> { Take{iter: self, n: n} } @@ -329,6 +347,7 @@ pub trait Iterator<A> { /// assert!(it.next().is_none()); /// ``` #[inline] + #[unstable = "waiting for unboxed closures"] fn scan<'r, St, B>(self, initial_state: St, f: |&mut St, A|: 'r -> Option<B>) -> Scan<'r, A, B, Self, St> { Scan{iter: self, f: f, state: initial_state} @@ -353,6 +372,7 @@ pub trait Iterator<A> { /// } /// ``` #[inline] + #[unstable = "waiting for unboxed closures"] fn flat_map<'r, B, U: Iterator<B>>(self, f: |A|: 'r -> U) -> FlatMap<'r, A, Self, U> { FlatMap{iter: self, f: f, frontiter: None, backiter: None } @@ -386,6 +406,7 @@ pub trait Iterator<A> { /// assert_eq!(process(x.into_iter()), 1006); /// ``` #[inline] + #[stable] fn fuse(self) -> Fuse<Self> { Fuse{iter: self, done: false} } @@ -409,6 +430,7 @@ pub trait Iterator<A> { /// println!("{}", sum); /// ``` #[inline] + #[unstable = "waiting for unboxed closures"] fn inspect<'r>(self, f: |&A|: 'r) -> Inspect<'r, A, Self> { Inspect{iter: self, f: f} } @@ -428,6 +450,7 @@ pub trait Iterator<A> { /// // xs.next() is now `5` /// assert!(xs.next() == Some(5)); /// ``` + #[stable] fn by_ref<'r>(&'r mut self) -> ByRef<'r, Self> { ByRef{iter: self} } @@ -443,8 +466,9 @@ pub trait Iterator<A> { /// assert!(a.as_slice() == b.as_slice()); /// ``` #[inline] - fn collect<B: FromIterator<A>>(&mut self) -> B { - FromIterator::from_iter(self.by_ref()) + #[unstable = "waiting for general conversion traits, just changed to take self by value"] + fn collect<B: FromIterator<A>>(self) -> B { + FromIterator::from_iter(self) } /// Loops through `n` iterations, returning the `n`th element of the @@ -459,6 +483,7 @@ pub trait Iterator<A> { /// assert!(it.nth(2) == None); /// ``` #[inline] + #[stable] fn nth(&mut self, mut n: uint) -> Option<A> { for x in *self { if n == 0 { return Some(x) } @@ -477,9 +502,10 @@ pub trait Iterator<A> { /// assert!(a.iter().last().unwrap() == &5); /// ``` #[inline] - fn last(&mut self) -> Option<A> { + #[unstable = "just changed to take self by value"] + fn last(mut self) -> Option<A> { let mut last = None; - for x in *self { last = Some(x); } + for x in self { last = Some(x); } last } @@ -493,9 +519,10 @@ pub trait Iterator<A> { /// assert!(a.iter().fold(0, |a, &b| a + b) == 15); /// ``` #[inline] - fn fold<B>(&mut self, init: B, f: |B, A| -> B) -> B { + #[unstable = "waiting for unboxed closures, just changed to take self by value"] + fn fold<B>(mut self, init: B, f: |B, A| -> B) -> B { let mut accum = init; - for x in *self { + for x in self { accum = f(accum, x); } accum @@ -509,10 +536,10 @@ pub trait Iterator<A> { /// let a = [1i, 2, 3, 4, 5]; /// let mut it = a.iter(); /// assert!(it.count() == 5); - /// assert!(it.count() == 0); /// ``` #[inline] - fn count(&mut self) -> uint { + #[unstable = "just changed to take self by value"] + fn count(self) -> uint { self.fold(0, |cnt, _x| cnt + 1) } @@ -526,8 +553,9 @@ pub trait Iterator<A> { /// assert!(!a.iter().all(|x| *x > 2)); /// ``` #[inline] - fn all(&mut self, f: |A| -> bool) -> bool { - for x in *self { if !f(x) { return false; } } + #[unstable = "waiting for unboxed closures, just changed to take self by value"] + fn all(mut self, f: |A| -> bool) -> bool { + for x in self { if !f(x) { return false; } } true } @@ -543,6 +571,7 @@ pub trait Iterator<A> { /// assert!(!it.any(|x| *x == 3)); /// ``` #[inline] + #[unstable = "waiting for unboxed closures"] fn any(&mut self, f: |A| -> bool) -> bool { for x in *self { if f(x) { return true; } } false @@ -552,6 +581,7 @@ pub trait Iterator<A> { /// /// Does not consume the iterator past the first found element. #[inline] + #[unstable = "waiting for unboxed closures"] fn find(&mut self, predicate: |&A| -> bool) -> Option<A> { for x in *self { if predicate(&x) { return Some(x) } @@ -561,6 +591,7 @@ pub trait Iterator<A> { /// Return the index of the first element satisfying the specified predicate #[inline] + #[unstable = "waiting for unboxed closures"] fn position(&mut self, predicate: |A| -> bool) -> Option<uint> { let mut i = 0; for x in *self { @@ -584,7 +615,8 @@ pub trait Iterator<A> { /// assert_eq!(*xs.iter().max_by(|x| x.abs()).unwrap(), -10); /// ``` #[inline] - fn max_by<B: Ord>(&mut self, f: |&A| -> B) -> Option<A> { + #[unstable = "waiting for unboxed closures, just changed to take self by value"] + fn max_by<B: Ord>(self, f: |&A| -> B) -> Option<A> { self.fold(None, |max: Option<(A, B)>, x| { let x_val = f(&x); match max { @@ -610,7 +642,8 @@ pub trait Iterator<A> { /// assert_eq!(*xs.iter().min_by(|x| x.abs()).unwrap(), 0); /// ``` #[inline] - fn min_by<B: Ord>(&mut self, f: |&A| -> B) -> Option<A> { + #[unstable = "waiting for unboxed closures, just changed to take self by value"] + fn min_by<B: Ord>(self, f: |&A| -> B) -> Option<A> { self.fold(None, |min: Option<(A, B)>, x| { let x_val = f(&x); match min { @@ -625,14 +658,22 @@ pub trait Iterator<A> { } } +#[unstable = "trait is unstable"] +impl<A, I> IteratorExt<A> for I where I: Iterator<A> {} + /// A range iterator able to yield elements from both ends /// /// A `DoubleEndedIterator` can be thought of as a deque in that `next()` and `next_back()` exhaust /// elements from the *same* range, and do not work independently of each other. +#[unstable = "recently split into two traits"] pub trait DoubleEndedIterator<A>: Iterator<A> { /// Yield an element from the end of the range, returning `None` if the range is empty. fn next_back(&mut self) -> Option<A>; +} +/// Extension methods for double-ended iterators. +#[unstable = "new extension trait convention"] +pub trait DoubleEndedIteratorExt<A>: DoubleEndedIterator<A> { /// Change the direction of the iterator /// /// The flipped iterator swaps the ends on an iterator that can already @@ -646,18 +687,24 @@ pub trait DoubleEndedIterator<A>: Iterator<A> { /// Note: Random access with flipped indices still only applies to the first /// `uint::MAX` elements of the original iterator. #[inline] + #[stable] fn rev(self) -> Rev<Self> { Rev{iter: self} } } +#[unstable = "trait is unstable"] +impl<A, I> DoubleEndedIteratorExt<A> for I where I: DoubleEndedIterator<A> {} + /// A double-ended iterator yielding mutable references +#[experimental = "not widely used"] pub trait MutableDoubleEndedIterator { // FIXME: #5898: should be called `reverse` /// Use an iterator to reverse a container in-place fn reverse_(&mut self); } +#[experimental = "trait is experimental"] impl<'a, A:'a, T: DoubleEndedIterator<&'a mut A>> MutableDoubleEndedIterator for T { // FIXME: #5898: should be called `reverse` /// Use an iterator to reverse a container in-place @@ -678,6 +725,7 @@ impl<'a, A:'a, T: DoubleEndedIterator<&'a mut A>> MutableDoubleEndedIterator for /// Calling `next()` or `next_back()` on a `RandomAccessIterator` /// reduces the indexable range accordingly. That is, `it.idx(1)` will become `it.idx(0)` /// after `it.next()` is called. +#[experimental = "not widely used, may be better decomposed into Index and ExactSizeIterator"] pub trait RandomAccessIterator<A>: Iterator<A> { /// Return the number of indexable elements. At most `std::uint::MAX` /// elements are indexable, even if the iterator represents a longer range. @@ -694,7 +742,8 @@ pub trait RandomAccessIterator<A>: Iterator<A> { /// /// `Iterator::size_hint` *must* return the exact size of the iterator. /// Note that the size must fit in `uint`. -pub trait ExactSize<A> : DoubleEndedIterator<A> { +#[unstable = "could move DoubleEndedIterator bound onto rposition with method-level where clauses"] +pub trait ExactSizeIterator<A> : DoubleEndedIterator<A> { /// Return the index of the last element satisfying the specified predicate /// /// If no element matches, None is returned. @@ -702,7 +751,7 @@ pub trait ExactSize<A> : DoubleEndedIterator<A> { fn rposition(&mut self, predicate: |A| -> bool) -> Option<uint> { let len = self.len(); for i in range(0, len).rev() { - if predicate(self.next_back().expect("rposition: incorrect ExactSize")) { + if predicate(self.next_back().expect("rposition: incorrect ExactSizeIterator")) { return Some(i); } } @@ -724,19 +773,27 @@ pub trait ExactSize<A> : DoubleEndedIterator<A> { // All adaptors that preserve the size of the wrapped iterator are fine // Adaptors that may overflow in `size_hint` are not, i.e. `Chain`. -impl<A, T: ExactSize<A>> ExactSize<(uint, A)> for Enumerate<T> {} -impl<'a, A, T: ExactSize<A>> ExactSize<A> for Inspect<'a, A, T> {} -impl<A, T: ExactSize<A>> ExactSize<A> for Rev<T> {} -impl<'a, A, B, T: ExactSize<A>> ExactSize<B> for Map<'a, A, B, T> {} -impl<A, B, T: ExactSize<A>, U: ExactSize<B>> ExactSize<(A, B)> for Zip<T, U> {} +#[unstable = "trait is unstable"] +impl<A, T: ExactSizeIterator<A>> ExactSizeIterator<(uint, A)> for Enumerate<T> {} +#[unstable = "trait is unstable"] +impl<'a, A, T: ExactSizeIterator<A>> ExactSizeIterator<A> for Inspect<'a, A, T> {} +#[unstable = "trait is unstable"] +impl<A, T: ExactSizeIterator<A>> ExactSizeIterator<A> for Rev<T> {} +#[unstable = "trait is unstable"] +impl<'a, A, B, T: ExactSizeIterator<A>> ExactSizeIterator<B> for Map<'a, A, B, T> {} +#[unstable = "trait is unstable"] +impl<A, B, T, U> ExactSizeIterator<(A, B)> for Zip<T, U> + where T: ExactSizeIterator<A>, U: ExactSizeIterator<B> {} /// An double-ended iterator with the direction inverted #[deriving(Clone)] #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] +#[stable] pub struct Rev<T> { iter: T } +#[unstable = "trait is unstable"] impl<A, T: DoubleEndedIterator<A>> Iterator<A> for Rev<T> { #[inline] fn next(&mut self) -> Option<A> { self.iter.next_back() } @@ -744,11 +801,13 @@ impl<A, T: DoubleEndedIterator<A>> Iterator<A> for Rev<T> { fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() } } +#[unstable = "trait is unstable"] impl<A, T: DoubleEndedIterator<A>> DoubleEndedIterator<A> for Rev<T> { #[inline] fn next_back(&mut self) -> Option<A> { self.iter.next() } } +#[experimental = "trait is experimental"] impl<A, T: DoubleEndedIterator<A> + RandomAccessIterator<A>> RandomAccessIterator<A> for Rev<T> { #[inline] @@ -762,10 +821,12 @@ impl<A, T: DoubleEndedIterator<A> + RandomAccessIterator<A>> RandomAccessIterato /// A mutable reference to an iterator #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] +#[stable] pub struct ByRef<'a, T:'a> { iter: &'a mut T } +#[unstable = "trait is unstable"] impl<'a, A, T: Iterator<A>+'a> Iterator<A> for ByRef<'a, T> { #[inline] fn next(&mut self) -> Option<A> { self.iter.next() } @@ -773,12 +834,14 @@ impl<'a, A, T: Iterator<A>+'a> Iterator<A> for ByRef<'a, T> { fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() } } +#[unstable = "trait is unstable"] impl<'a, A, T: DoubleEndedIterator<A>+'a> DoubleEndedIterator<A> for ByRef<'a, T> { #[inline] fn next_back(&mut self) -> Option<A> { self.iter.next_back() } } /// A trait for iterators over elements which can be added together +#[experimental = "needs to be re-evaluated as part of numerics reform"] pub trait AdditiveIterator<A> { /// Iterates over the entire iterator, summing up all the elements /// @@ -791,14 +854,15 @@ pub trait AdditiveIterator<A> { /// let mut it = a.iter().map(|&x| x); /// assert!(it.sum() == 15); /// ``` - fn sum(&mut self) -> A; + fn sum(self) -> A; } macro_rules! impl_additive { ($A:ty, $init:expr) => { + #[experimental = "trait is experimental"] impl<T: Iterator<$A>> AdditiveIterator<$A> for T { #[inline] - fn sum(&mut self) -> $A { + fn sum(self) -> $A { self.fold($init, |acc, x| acc + x) } } @@ -818,6 +882,7 @@ impl_additive!(f32, 0.0) impl_additive!(f64, 0.0) /// A trait for iterators over elements which can be multiplied together. +#[experimental = "needs to be re-evaluated as part of numerics reform"] pub trait MultiplicativeIterator<A> { /// Iterates over the entire iterator, multiplying all the elements /// @@ -833,14 +898,15 @@ pub trait MultiplicativeIterator<A> { /// assert!(factorial(1) == 1); /// assert!(factorial(5) == 120); /// ``` - fn product(&mut self) -> A; + fn product(self) -> A; } macro_rules! impl_multiplicative { ($A:ty, $init:expr) => { + #[experimental = "trait is experimental"] impl<T: Iterator<$A>> MultiplicativeIterator<$A> for T { #[inline] - fn product(&mut self) -> $A { + fn product(self) -> $A { self.fold($init, |acc, x| acc * x) } } @@ -860,7 +926,8 @@ impl_multiplicative!(f32, 1.0) impl_multiplicative!(f64, 1.0) /// A trait for iterators over elements which can be compared to one another. -pub trait OrdIterator<A> { +#[unstable = "recently renamed for new extension trait conventions"] +pub trait IteratorOrdExt<A> { /// Consumes the entire iterator to return the maximum element. /// /// # Example @@ -869,7 +936,7 @@ pub trait OrdIterator<A> { /// let a = [1i, 2, 3, 4, 5]; /// assert!(a.iter().max().unwrap() == &5); /// ``` - fn max(&mut self) -> Option<A>; + fn max(self) -> Option<A>; /// Consumes the entire iterator to return the minimum element. /// @@ -879,7 +946,7 @@ pub trait OrdIterator<A> { /// let a = [1i, 2, 3, 4, 5]; /// assert!(a.iter().min().unwrap() == &1); /// ``` - fn min(&mut self) -> Option<A>; + fn min(self) -> Option<A>; /// `min_max` finds the minimum and maximum elements in the iterator. /// @@ -914,12 +981,13 @@ pub trait OrdIterator<A> { /// let v = [1i, 1, 1, 1]; /// assert!(v.iter().min_max() == MinMax(&1, &1)); /// ``` - fn min_max(&mut self) -> MinMaxResult<A>; + fn min_max(self) -> MinMaxResult<A>; } -impl<A: Ord, T: Iterator<A>> OrdIterator<A> for T { +#[unstable = "trait is unstable"] +impl<A: Ord, T: Iterator<A>> IteratorOrdExt<A> for T { #[inline] - fn max(&mut self) -> Option<A> { + fn max(self) -> Option<A> { self.fold(None, |max, x| { match max { None => Some(x), @@ -929,7 +997,7 @@ impl<A: Ord, T: Iterator<A>> OrdIterator<A> for T { } #[inline] - fn min(&mut self) -> Option<A> { + fn min(self) -> Option<A> { self.fold(None, |min, x| { match min { None => Some(x), @@ -938,7 +1006,7 @@ impl<A: Ord, T: Iterator<A>> OrdIterator<A> for T { }) } - fn min_max(&mut self) -> MinMaxResult<A> { + fn min_max(mut self) -> MinMaxResult<A> { let (mut min, mut max) = match self.next() { None => return NoElements, Some(x) => { @@ -982,8 +1050,9 @@ impl<A: Ord, T: Iterator<A>> OrdIterator<A> for T { } } -/// `MinMaxResult` is an enum returned by `min_max`. See `OrdIterator::min_max` for more detail. +/// `MinMaxResult` is an enum returned by `min_max`. See `IteratorOrdExt::min_max` for more detail. #[deriving(Clone, PartialEq, Show)] +#[unstable = "waiting on namespaced enum conventions"] pub enum MinMaxResult<T> { /// Empty iterator NoElements, @@ -995,6 +1064,7 @@ pub enum MinMaxResult<T> { MinMax(T, T) } +#[stable] impl<T: Clone> MinMaxResult<T> { /// `into_option` creates an `Option` of type `(T,T)`. The returned `Option` has variant /// `None` if and only if the `MinMaxResult` has variant `NoElements`. Otherwise variant @@ -1025,14 +1095,15 @@ impl<T: Clone> MinMaxResult<T> { } /// A trait for iterators that contain cloneable elements -pub trait CloneIteratorExt<A> { +#[unstable = "recently renamed for extension trait conventions"] +pub trait IteratorCloneExt<A> { /// Creates an iterator that clones the elements it yields. Useful for converting an /// Iterator<&T> to an Iterator<T>. fn cloned(self) -> Cloned<Self>; } - -impl<A: Clone, D: Deref<A>, I: Iterator<D>> CloneIteratorExt<A> for I { +#[unstable = "trait is unstable"] +impl<A: Clone, D: Deref<A>, I: Iterator<D>> IteratorCloneExt<A> for I { fn cloned(self) -> Cloned<I> { Cloned { it: self } } @@ -1060,28 +1131,31 @@ impl<A: Clone, D: Deref<A>, I: DoubleEndedIterator<D>> } } -impl<A: Clone, D: Deref<A>, I: ExactSize<D>> ExactSize<A> for Cloned<I> {} +#[unstable = "trait is unstable"] +impl<A: Clone, D: Deref<A>, I: ExactSizeIterator<D>> ExactSizeIterator<A> for Cloned<I> {} -/// A trait for iterators that are cloneable. -pub trait CloneableIterator { +#[unstable = "recently renamed for extension trait conventions"] +/// An extension trait for cloneable iterators. +pub trait CloneIteratorExt { /// Repeats an iterator endlessly /// /// # Example /// /// ```rust - /// use std::iter::{CloneableIterator, count}; + /// use std::iter::{CloneIteratorExt, count}; /// /// let a = count(1i,1i).take(1); /// let mut cy = a.cycle(); /// assert_eq!(cy.next(), Some(1)); /// assert_eq!(cy.next(), Some(1)); /// ``` + #[stable] fn cycle(self) -> Cycle<Self>; } -impl<A, T: Clone + Iterator<A>> CloneableIterator for T { +impl<A, I> CloneIteratorExt for I where I: Iterator<A> + Clone { #[inline] - fn cycle(self) -> Cycle<T> { + fn cycle(self) -> Cycle<I> { Cycle{orig: self.clone(), iter: self} } } @@ -1089,11 +1163,13 @@ impl<A, T: Clone + Iterator<A>> CloneableIterator for T { /// An iterator that repeats endlessly #[deriving(Clone)] #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] +#[stable] pub struct Cycle<T> { orig: T, iter: T, } +#[unstable = "trait is unstable"] impl<A, T: Clone + Iterator<A>> Iterator<A> for Cycle<T> { #[inline] fn next(&mut self) -> Option<A> { @@ -1114,6 +1190,7 @@ impl<A, T: Clone + Iterator<A>> Iterator<A> for Cycle<T> { } } +#[experimental = "trait is experimental"] impl<A, T: Clone + RandomAccessIterator<A>> RandomAccessIterator<A> for Cycle<T> { #[inline] fn indexable(&self) -> uint { @@ -1141,12 +1218,14 @@ impl<A, T: Clone + RandomAccessIterator<A>> RandomAccessIterator<A> for Cycle<T> /// An iterator which strings two iterators together #[deriving(Clone)] #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] +#[stable] pub struct Chain<T, U> { a: T, b: U, flag: bool, } +#[unstable = "trait is unstable"] impl<A, T: Iterator<A>, U: Iterator<A>> Iterator<A> for Chain<T, U> { #[inline] fn next(&mut self) -> Option<A> { @@ -1178,6 +1257,7 @@ impl<A, T: Iterator<A>, U: Iterator<A>> Iterator<A> for Chain<T, U> { } } +#[unstable = "trait is unstable"] impl<A, T: DoubleEndedIterator<A>, U: DoubleEndedIterator<A>> DoubleEndedIterator<A> for Chain<T, U> { #[inline] @@ -1189,6 +1269,7 @@ for Chain<T, U> { } } +#[experimental = "trait is experimental"] impl<A, T: RandomAccessIterator<A>, U: RandomAccessIterator<A>> RandomAccessIterator<A> for Chain<T, U> { #[inline] @@ -1211,11 +1292,13 @@ for Chain<T, U> { /// An iterator which iterates two other iterators simultaneously #[deriving(Clone)] #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] +#[stable] pub struct Zip<T, U> { a: T, b: U } +#[unstable = "trait is unstable"] impl<A, B, T: Iterator<A>, U: Iterator<B>> Iterator<(A, B)> for Zip<T, U> { #[inline] fn next(&mut self) -> Option<(A, B)> { @@ -1246,7 +1329,8 @@ impl<A, B, T: Iterator<A>, U: Iterator<B>> Iterator<(A, B)> for Zip<T, U> { } } -impl<A, B, T: ExactSize<A>, U: ExactSize<B>> DoubleEndedIterator<(A, B)> +#[unstable = "trait is unstable"] +impl<A, B, T: ExactSizeIterator<A>, U: ExactSizeIterator<B>> DoubleEndedIterator<(A, B)> for Zip<T, U> { #[inline] fn next_back(&mut self) -> Option<(A, B)> { @@ -1268,6 +1352,7 @@ for Zip<T, U> { } } +#[experimental = "trait is experimental"] impl<A, B, T: RandomAccessIterator<A>, U: RandomAccessIterator<B>> RandomAccessIterator<(A, B)> for Zip<T, U> { #[inline] @@ -1289,6 +1374,7 @@ RandomAccessIterator<(A, B)> for Zip<T, U> { /// An iterator which maps the values of `iter` with `f` #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] +#[stable] pub struct Map<'a, A, B, T> { iter: T, f: |A|: 'a -> B @@ -1304,6 +1390,7 @@ impl<'a, A, B, T> Map<'a, A, B, T> { } } +#[unstable = "trait is unstable"] impl<'a, A, B, T: Iterator<A>> Iterator<B> for Map<'a, A, B, T> { #[inline] fn next(&mut self) -> Option<B> { @@ -1317,6 +1404,7 @@ impl<'a, A, B, T: Iterator<A>> Iterator<B> for Map<'a, A, B, T> { } } +#[unstable = "trait is unstable"] impl<'a, A, B, T: DoubleEndedIterator<A>> DoubleEndedIterator<B> for Map<'a, A, B, T> { #[inline] fn next_back(&mut self) -> Option<B> { @@ -1325,6 +1413,7 @@ impl<'a, A, B, T: DoubleEndedIterator<A>> DoubleEndedIterator<B> for Map<'a, A, } } +#[experimental = "trait is experimental"] impl<'a, A, B, T: RandomAccessIterator<A>> RandomAccessIterator<B> for Map<'a, A, B, T> { #[inline] fn indexable(&self) -> uint { @@ -1340,11 +1429,13 @@ impl<'a, A, B, T: RandomAccessIterator<A>> RandomAccessIterator<B> for Map<'a, A /// An iterator which filters the elements of `iter` with `predicate` #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] +#[stable] pub struct Filter<'a, A, T> { iter: T, predicate: |&A|: 'a -> bool } +#[unstable = "trait is unstable"] impl<'a, A, T: Iterator<A>> Iterator<A> for Filter<'a, A, T> { #[inline] fn next(&mut self) -> Option<A> { @@ -1365,6 +1456,7 @@ impl<'a, A, T: Iterator<A>> Iterator<A> for Filter<'a, A, T> { } } +#[unstable = "trait is unstable"] impl<'a, A, T: DoubleEndedIterator<A>> DoubleEndedIterator<A> for Filter<'a, A, T> { #[inline] fn next_back(&mut self) -> Option<A> { @@ -1379,11 +1471,13 @@ impl<'a, A, T: DoubleEndedIterator<A>> DoubleEndedIterator<A> for Filter<'a, A, /// An iterator which uses `f` to both filter and map elements from `iter` #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] +#[stable] pub struct FilterMap<'a, A, B, T> { iter: T, f: |A|: 'a -> Option<B> } +#[unstable = "trait is unstable"] impl<'a, A, B, T: Iterator<A>> Iterator<B> for FilterMap<'a, A, B, T> { #[inline] fn next(&mut self) -> Option<B> { @@ -1403,6 +1497,7 @@ impl<'a, A, B, T: Iterator<A>> Iterator<B> for FilterMap<'a, A, B, T> { } } +#[unstable = "trait is unstable"] impl<'a, A, B, T: DoubleEndedIterator<A>> DoubleEndedIterator<B> for FilterMap<'a, A, B, T> { #[inline] @@ -1420,11 +1515,13 @@ for FilterMap<'a, A, B, T> { /// An iterator which yields the current count and the element during iteration #[deriving(Clone)] #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] +#[stable] pub struct Enumerate<T> { iter: T, count: uint } +#[unstable = "trait is unstable"] impl<A, T: Iterator<A>> Iterator<(uint, A)> for Enumerate<T> { #[inline] fn next(&mut self) -> Option<(uint, A)> { @@ -1444,7 +1541,8 @@ impl<A, T: Iterator<A>> Iterator<(uint, A)> for Enumerate<T> { } } -impl<A, T: ExactSize<A>> DoubleEndedIterator<(uint, A)> for Enumerate<T> { +#[unstable = "trait is unstable"] +impl<A, T: ExactSizeIterator<A>> DoubleEndedIterator<(uint, A)> for Enumerate<T> { #[inline] fn next_back(&mut self) -> Option<(uint, A)> { match self.iter.next_back() { @@ -1457,6 +1555,7 @@ impl<A, T: ExactSize<A>> DoubleEndedIterator<(uint, A)> for Enumerate<T> { } } +#[experimental = "trait is experimental"] impl<A, T: RandomAccessIterator<A>> RandomAccessIterator<(uint, A)> for Enumerate<T> { #[inline] fn indexable(&self) -> uint { @@ -1474,11 +1573,13 @@ impl<A, T: RandomAccessIterator<A>> RandomAccessIterator<(uint, A)> for Enumerat /// An iterator with a `peek()` that returns an optional reference to the next element. #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] +#[stable] pub struct Peekable<A, T> { iter: T, peeked: Option<A>, } +#[unstable = "trait is unstable"] impl<A, T: Iterator<A>> Iterator<A> for Peekable<A, T> { #[inline] fn next(&mut self) -> Option<A> { @@ -1502,6 +1603,7 @@ impl<A, T: Iterator<A>> Iterator<A> for Peekable<A, T> { } } +#[stable] impl<'a, A, T: Iterator<A>> Peekable<A, T> { /// Return a reference to the next element of the iterator with out advancing it, /// or None if the iterator is exhausted. @@ -1525,12 +1627,14 @@ impl<'a, A, T: Iterator<A>> Peekable<A, T> { /// An iterator which rejects elements while `predicate` is true #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] +#[stable] pub struct SkipWhile<'a, A, T> { iter: T, flag: bool, predicate: |&A|: 'a -> bool } +#[unstable = "trait is unstable"] impl<'a, A, T: Iterator<A>> Iterator<A> for SkipWhile<'a, A, T> { #[inline] fn next(&mut self) -> Option<A> { @@ -1552,12 +1656,14 @@ impl<'a, A, T: Iterator<A>> Iterator<A> for SkipWhile<'a, A, T> { /// An iterator which only accepts elements while `predicate` is true #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] +#[stable] pub struct TakeWhile<'a, A, T> { iter: T, flag: bool, predicate: |&A|: 'a -> bool } +#[unstable = "trait is unstable"] impl<'a, A, T: Iterator<A>> Iterator<A> for TakeWhile<'a, A, T> { #[inline] fn next(&mut self) -> Option<A> { @@ -1588,11 +1694,13 @@ impl<'a, A, T: Iterator<A>> Iterator<A> for TakeWhile<'a, A, T> { /// An iterator which skips over `n` elements of `iter`. #[deriving(Clone)] #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] +#[stable] pub struct Skip<T> { iter: T, n: uint } +#[unstable = "trait is unstable"] impl<A, T: Iterator<A>> Iterator<A> for Skip<T> { #[inline] fn next(&mut self) -> Option<A> { @@ -1634,6 +1742,7 @@ impl<A, T: Iterator<A>> Iterator<A> for Skip<T> { } } +#[experimental = "trait is experimental"] impl<A, T: RandomAccessIterator<A>> RandomAccessIterator<A> for Skip<T> { #[inline] fn indexable(&self) -> uint { @@ -1653,11 +1762,13 @@ impl<A, T: RandomAccessIterator<A>> RandomAccessIterator<A> for Skip<T> { /// An iterator which only iterates over the first `n` iterations of `iter`. #[deriving(Clone)] #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] +#[stable] pub struct Take<T> { iter: T, n: uint } +#[unstable = "trait is unstable"] impl<A, T: Iterator<A>> Iterator<A> for Take<T> { #[inline] fn next(&mut self) -> Option<A> { @@ -1684,6 +1795,7 @@ impl<A, T: Iterator<A>> Iterator<A> for Take<T> { } } +#[experimental = "trait is experimental"] impl<A, T: RandomAccessIterator<A>> RandomAccessIterator<A> for Take<T> { #[inline] fn indexable(&self) -> uint { @@ -1703,6 +1815,7 @@ impl<A, T: RandomAccessIterator<A>> RandomAccessIterator<A> for Take<T> { /// An iterator to maintain state while iterating another iterator #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] +#[unstable = "waiting for unboxed closures"] pub struct Scan<'a, A, B, T, St> { iter: T, f: |&mut St, A|: 'a -> Option<B>, @@ -1711,6 +1824,7 @@ pub struct Scan<'a, A, B, T, St> { pub state: St, } +#[unstable = "trait is unstable"] impl<'a, A, B, T: Iterator<A>, St> Iterator<B> for Scan<'a, A, B, T, St> { #[inline] fn next(&mut self) -> Option<B> { @@ -1728,6 +1842,7 @@ impl<'a, A, B, T: Iterator<A>, St> Iterator<B> for Scan<'a, A, B, T, St> { /// and yields the elements of the produced iterators /// #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] +#[unstable = "waiting for unboxed closures"] pub struct FlatMap<'a, A, T, U> { iter: T, f: |A|: 'a -> U, @@ -1735,6 +1850,7 @@ pub struct FlatMap<'a, A, T, U> { backiter: Option<U>, } +#[unstable = "trait is unstable"] impl<'a, A, T: Iterator<A>, B, U: Iterator<B>> Iterator<B> for FlatMap<'a, A, T, U> { #[inline] fn next(&mut self) -> Option<B> { @@ -1763,6 +1879,7 @@ impl<'a, A, T: Iterator<A>, B, U: Iterator<B>> Iterator<B> for FlatMap<'a, A, T, } } +#[unstable = "trait is unstable"] impl<'a, A, T: DoubleEndedIterator<A>, B, U: DoubleEndedIterator<B>> DoubleEndedIterator<B> @@ -1788,11 +1905,13 @@ impl<'a, /// yields `None` once. #[deriving(Clone)] #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] +#[stable] pub struct Fuse<T> { iter: T, done: bool } +#[unstable = "trait is unstable"] impl<A, T: Iterator<A>> Iterator<A> for Fuse<T> { #[inline] fn next(&mut self) -> Option<A> { @@ -1819,6 +1938,7 @@ impl<A, T: Iterator<A>> Iterator<A> for Fuse<T> { } } +#[unstable = "trait is unstable"] impl<A, T: DoubleEndedIterator<A>> DoubleEndedIterator<A> for Fuse<T> { #[inline] fn next_back(&mut self) -> Option<A> { @@ -1837,6 +1957,7 @@ impl<A, T: DoubleEndedIterator<A>> DoubleEndedIterator<A> for Fuse<T> { } // Allow RandomAccessIterators to be fused without affecting random-access behavior +#[experimental = "trait is experimental"] impl<A, T: RandomAccessIterator<A>> RandomAccessIterator<A> for Fuse<T> { #[inline] fn indexable(&self) -> uint { @@ -1849,6 +1970,7 @@ impl<A, T: RandomAccessIterator<A>> RandomAccessIterator<A> for Fuse<T> { } } +#[experimental = "seems marginal"] impl<T> Fuse<T> { /// Resets the fuse such that the next call to .next() or .next_back() will /// call the underlying iterator again even if it previously returned None. @@ -1861,6 +1983,7 @@ impl<T> Fuse<T> { /// An iterator that calls a function with a reference to each /// element before yielding it. #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] +#[unstable = "waiting for unboxed closures"] pub struct Inspect<'a, A, T> { iter: T, f: |&A|: 'a @@ -1878,6 +2001,7 @@ impl<'a, A, T> Inspect<'a, A, T> { } } +#[unstable = "trait is unstable"] impl<'a, A, T: Iterator<A>> Iterator<A> for Inspect<'a, A, T> { #[inline] fn next(&mut self) -> Option<A> { @@ -1891,6 +2015,7 @@ impl<'a, A, T: Iterator<A>> Iterator<A> for Inspect<'a, A, T> { } } +#[unstable = "trait is unstable"] impl<'a, A, T: DoubleEndedIterator<A>> DoubleEndedIterator<A> for Inspect<'a, A, T> { #[inline] @@ -1900,6 +2025,7 @@ for Inspect<'a, A, T> { } } +#[experimental = "trait is experimental"] impl<'a, A, T: RandomAccessIterator<A>> RandomAccessIterator<A> for Inspect<'a, A, T> { #[inline] @@ -1915,12 +2041,14 @@ for Inspect<'a, A, T> { } /// An iterator which just modifies the contained state throughout iteration. +#[experimental] pub struct Unfold<'a, A, St> { f: |&mut St|: 'a -> Option<A>, /// Internal state that will be yielded on the next iteration pub state: St, } +#[experimental] impl<'a, A, St> Unfold<'a, A, St> { /// Creates a new iterator with the specified closure as the "iterator /// function" and an initial state to eventually pass to the iterator @@ -1934,6 +2062,7 @@ impl<'a, A, St> Unfold<'a, A, St> { } } +#[experimental] impl<'a, A, St> Iterator<A> for Unfold<'a, A, St> { #[inline] fn next(&mut self) -> Option<A> { @@ -1950,6 +2079,7 @@ impl<'a, A, St> Iterator<A> for Unfold<'a, A, St> { /// An infinite iterator starting at `start` and advancing by `step` with each /// iteration #[deriving(Clone)] +#[unstable = "may be renamed"] pub struct Counter<A> { /// The current state the counter is at (next value to be yielded) state: A, @@ -1959,10 +2089,12 @@ pub struct Counter<A> { /// Creates a new counter with the specified start/step #[inline] +#[unstable = "may be renamed"] pub fn count<A>(start: A, step: A) -> Counter<A> { Counter{state: start, step: step} } +#[unstable = "trait is unstable"] impl<A: Add<A, A> + Clone> Iterator<A> for Counter<A> { #[inline] fn next(&mut self) -> Option<A> { @@ -1979,6 +2111,7 @@ impl<A: Add<A, A> + Clone> Iterator<A> for Counter<A> { /// An iterator over the range [start, stop) #[deriving(Clone)] +#[unstable = "may be refactored due to numerics reform or ops reform"] pub struct Range<A> { state: A, stop: A, @@ -2008,6 +2141,7 @@ pub fn range<A: Int>(start: A, stop: A) -> Range<A> { } // FIXME: #10414: Unfortunate type bound +#[unstable = "trait is unstable"] impl<A: Int + ToPrimitive> Iterator<A> for Range<A> { #[inline] fn next(&mut self) -> Option<A> { @@ -2055,6 +2189,7 @@ impl<A: Int + ToPrimitive> Iterator<A> for Range<A> { /// `Int` is required to ensure the range will be the same regardless of /// the direction it is consumed. +#[unstable = "trait is unstable"] impl<A: Int + ToPrimitive> DoubleEndedIterator<A> for Range<A> { #[inline] fn next_back(&mut self) -> Option<A> { @@ -2069,6 +2204,7 @@ impl<A: Int + ToPrimitive> DoubleEndedIterator<A> for Range<A> { /// An iterator over the range [start, stop] #[deriving(Clone)] +#[unstable = "may be refactored due to numerics reform or ops reform"] pub struct RangeInclusive<A> { range: Range<A>, done: bool, @@ -2076,6 +2212,7 @@ pub struct RangeInclusive<A> { /// Return an iterator over the range [start, stop] #[inline] +#[unstable = "may be refactored due to numerics reform or ops reform"] pub fn range_inclusive<A: Int>(start: A, stop: A) -> RangeInclusive<A> { RangeInclusive { range: range(start, stop), @@ -2083,6 +2220,7 @@ pub fn range_inclusive<A: Int>(start: A, stop: A) -> RangeInclusive<A> { } } +#[unstable = "trait is unstable"] impl<A: Int + ToPrimitive> Iterator<A> for RangeInclusive<A> { #[inline] fn next(&mut self) -> Option<A> { @@ -2115,6 +2253,7 @@ impl<A: Int + ToPrimitive> Iterator<A> for RangeInclusive<A> { } } +#[unstable = "trait is unstable"] impl<A: Int + ToPrimitive> DoubleEndedIterator<A> for RangeInclusive<A> { #[inline] fn next_back(&mut self) -> Option<A> { @@ -2133,6 +2272,7 @@ impl<A: Int + ToPrimitive> DoubleEndedIterator<A> for RangeInclusive<A> { /// An iterator over the range [start, stop) by `step`. It handles overflow by stopping. #[deriving(Clone)] +#[unstable = "may be refactored due to numerics reform or ops reform"] pub struct RangeStep<A> { state: A, stop: A, @@ -2142,11 +2282,13 @@ pub struct RangeStep<A> { /// Return an iterator over the range [start, stop) by `step`. It handles overflow by stopping. #[inline] +#[unstable = "may be refactored due to numerics reform or ops reform"] pub fn range_step<A: Int>(start: A, stop: A, step: A) -> RangeStep<A> { let rev = step < Int::zero(); RangeStep{state: start, stop: stop, step: step, rev: rev} } +#[unstable = "trait is unstable"] impl<A: Int> Iterator<A> for RangeStep<A> { #[inline] fn next(&mut self) -> Option<A> { @@ -2165,6 +2307,7 @@ impl<A: Int> Iterator<A> for RangeStep<A> { /// An iterator over the range [start, stop] by `step`. It handles overflow by stopping. #[deriving(Clone)] +#[unstable = "may be refactored due to numerics reform or ops reform"] pub struct RangeStepInclusive<A> { state: A, stop: A, @@ -2175,6 +2318,7 @@ pub struct RangeStepInclusive<A> { /// Return an iterator over the range [start, stop] by `step`. It handles overflow by stopping. #[inline] +#[unstable = "may be refactored due to numerics reform or ops reform"] pub fn range_step_inclusive<A: Int>(start: A, stop: A, step: A) -> RangeStepInclusive<A> { let rev = step < Int::zero(); RangeStepInclusive { @@ -2186,6 +2330,7 @@ pub fn range_step_inclusive<A: Int>(start: A, stop: A, step: A) -> RangeStepIncl } } +#[unstable = "trait is unstable"] impl<A: Int> Iterator<A> for RangeStepInclusive<A> { #[inline] fn next(&mut self) -> Option<A> { @@ -2205,6 +2350,7 @@ impl<A: Int> Iterator<A> for RangeStepInclusive<A> { /// An iterator that repeats an element endlessly #[deriving(Clone)] +#[stable] pub struct Repeat<A> { element: A } @@ -2212,11 +2358,13 @@ pub struct Repeat<A> { impl<A: Clone> Repeat<A> { /// Create a new `Repeat` that endlessly repeats the element `elt`. #[inline] + #[deprecated = "use iter::repeat instead"] pub fn new(elt: A) -> Repeat<A> { Repeat{element: elt} } } +#[unstable = "trait is unstable"] impl<A: Clone> Iterator<A> for Repeat<A> { #[inline] fn next(&mut self) -> Option<A> { self.idx(0) } @@ -2224,11 +2372,13 @@ impl<A: Clone> Iterator<A> for Repeat<A> { fn size_hint(&self) -> (uint, Option<uint>) { (uint::MAX, None) } } +#[unstable = "trait is unstable"] impl<A: Clone> DoubleEndedIterator<A> for Repeat<A> { #[inline] fn next_back(&mut self) -> Option<A> { self.idx(0) } } +#[experimental = "trait is experimental"] impl<A: Clone> RandomAccessIterator<A> for Repeat<A> { #[inline] fn indexable(&self) -> uint { uint::MAX } @@ -2240,10 +2390,12 @@ type IterateState<'a, T> = (|T|: 'a -> T, Option<T>, bool); /// An iterator that repeatedly applies a given function, starting /// from a given seed value. +#[experimental] pub type Iterate<'a, T> = Unfold<'a, T, IterateState<'a, T>>; /// Create a new iterator that produces an infinite sequence of /// repeated applications of the given function `f`. +#[experimental] pub fn iterate<'a, T: Clone>(seed: T, f: |T|: 'a -> T) -> Iterate<'a, T> { Unfold::new((f, Some(seed), true), |st| { let &(ref mut f, ref mut val, ref mut first) = st; @@ -2262,8 +2414,10 @@ pub fn iterate<'a, T: Clone>(seed: T, f: |T|: 'a -> T) -> Iterate<'a, T> { } /// Create a new iterator that endlessly repeats the element `elt`. +#[inline] +#[stable] pub fn repeat<T: Clone>(elt: T) -> Repeat<T> { - Repeat::new(elt) + Repeat{element: elt} } /// Functions for lexicographical ordering of sequences. @@ -2273,6 +2427,7 @@ pub fn repeat<T: Clone>(elt: T) -> Repeat<T> { /// /// If two sequences are equal up until the point where one ends, /// the shorter sequence compares less. +#[experimental = "likely to be removed after cmp reform"] pub mod order { use cmp; use cmp::{Eq, Ord, PartialOrd, PartialEq}; diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index 07f2e154c76..ce61bd97e13 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -25,7 +25,7 @@ use clone::Clone; use cmp::{PartialEq, Eq}; use cmp::{PartialOrd, Ord}; use intrinsics; -use iter::Iterator; +use iter::IteratorExt; use kinds::Copy; use mem::size_of; use ops::{Add, Sub, Mul, Div, Rem, Neg}; diff --git a/src/libcore/option.rs b/src/libcore/option.rs index fcf2dab6908..7d7b41bf7bf 100644 --- a/src/libcore/option.rs +++ b/src/libcore/option.rs @@ -147,7 +147,7 @@ pub use self::Option::*; use cmp::{Eq, Ord}; use default::Default; -use iter::{Iterator, DoubleEndedIterator, FromIterator, ExactSize}; +use iter::{Iterator, IteratorExt, DoubleEndedIterator, FromIterator, ExactSizeIterator}; use mem; use result::{Result, Ok, Err}; use slice; @@ -797,7 +797,7 @@ impl<A> DoubleEndedIterator<A> for Item<A> { } } -impl<A> ExactSize<A> for Item<A> {} +impl<A> ExactSizeIterator<A> for Item<A> {} ///////////////////////////////////////////////////////////////////////////// // FromIterator diff --git a/src/libcore/prelude.rs b/src/libcore/prelude.rs index 9f883d60496..6678a20087b 100644 --- a/src/libcore/prelude.rs +++ b/src/libcore/prelude.rs @@ -39,7 +39,7 @@ pub use ops::{Slice, SliceMut}; pub use ops::{Fn, FnMut, FnOnce}; // Reexported functions -pub use iter::{range, repeat}; +pub use iter::range; pub use mem::drop; pub use str::from_str; @@ -50,9 +50,10 @@ pub use clone::Clone; pub use cmp::{PartialEq, PartialOrd, Eq, Ord}; pub use cmp::{Ordering, Equiv}; pub use cmp::Ordering::{Less, Equal, Greater}; -pub use iter::{FromIterator, Extend}; -pub use iter::{Iterator, DoubleEndedIterator, RandomAccessIterator, CloneableIterator}; -pub use iter::{OrdIterator, MutableDoubleEndedIterator, ExactSize}; +pub use iter::{FromIterator, Extend, IteratorExt}; +pub use iter::{Iterator, DoubleEndedIterator, DoubleEndedIteratorExt, RandomAccessIterator}; +pub use iter::{IteratorCloneExt, CloneIteratorExt}; +pub use iter::{IteratorOrdExt, MutableDoubleEndedIterator, ExactSizeIterator}; pub use num::{ToPrimitive, FromPrimitive}; pub use option::Option; pub use option::Option::{Some, None}; diff --git a/src/libcore/result.rs b/src/libcore/result.rs index 3240b4207a1..202ac464497 100644 --- a/src/libcore/result.rs +++ b/src/libcore/result.rs @@ -235,7 +235,7 @@ pub use self::Result::*; use std::fmt::Show; use slice; use slice::AsSlice; -use iter::{Iterator, DoubleEndedIterator, FromIterator, ExactSize}; +use iter::{Iterator, IteratorExt, DoubleEndedIterator, FromIterator, ExactSizeIterator}; use option::{None, Option, Some}; /// `Result` is a type that represents either success (`Ok`) or failure (`Err`). @@ -831,7 +831,7 @@ impl<A> DoubleEndedIterator<A> for Item<A> { } } -impl<A> ExactSize<A> for Item<A> {} +impl<A> ExactSizeIterator<A> for Item<A> {} ///////////////////////////////////////////////////////////////////////////// // FromIterator diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index 6625d19781a..36464e4d29e 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -1160,7 +1160,7 @@ impl<'a, T> Items<'a, T> { iterator!{struct Items -> *const T, &'a T} #[experimental = "needs review"] -impl<'a, T> ExactSize<&'a T> for Items<'a, T> {} +impl<'a, T> ExactSizeIterator<&'a T> for Items<'a, T> {} #[experimental = "needs review"] impl<'a, T> Clone for Items<'a, T> { @@ -1255,7 +1255,7 @@ impl<'a, T> MutItems<'a, T> { iterator!{struct MutItems -> *mut T, &'a mut T} #[experimental = "needs review"] -impl<'a, T> ExactSize<&'a mut T> for MutItems<'a, T> {} +impl<'a, T> ExactSizeIterator<&'a mut T> for MutItems<'a, T> {} /// An abstraction over the splitting iterators, so that splitn, splitn_mut etc /// can be implemented once. diff --git a/src/libcore/str.rs b/src/libcore/str.rs index bb7710c2acc..b9586399aec 100644 --- a/src/libcore/str.rs +++ b/src/libcore/str.rs @@ -23,9 +23,9 @@ use char::Char; use char; use cmp::{Eq, mod}; use default::Default; +use iter::{Map, Iterator, IteratorExt, DoubleEndedIterator}; +use iter::{DoubleEndedIteratorExt, ExactSizeIterator}; use iter::range; -use iter::{DoubleEndedIterator, ExactSize}; -use iter::{Map, Iterator}; use kinds::Sized; use mem; use num::Int; @@ -1210,7 +1210,7 @@ Section: Trait implementations #[allow(missing_docs)] pub mod traits { use cmp::{Ord, Ordering, Less, Equal, Greater, PartialEq, PartialOrd, Equiv, Eq}; - use iter::Iterator; + use iter::IteratorExt; use option::{Option, Some}; use ops; use str::{Str, StrPrelude, eq_slice}; diff --git a/src/libgetopts/lib.rs b/src/libgetopts/lib.rs index a182f582b5f..74165dcabc4 100644 --- a/src/libgetopts/lib.rs +++ b/src/libgetopts/lib.rs @@ -710,7 +710,7 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> String { let desc_sep = format!("\n{}", " ".repeat(24)); - let mut rows = opts.iter().map(|optref| { + let rows = opts.iter().map(|optref| { let OptGroup{short_name, long_name, hint, diff --git a/src/librand/isaac.rs b/src/librand/isaac.rs index 02dd53e4214..517b50c49c7 100644 --- a/src/librand/isaac.rs +++ b/src/librand/isaac.rs @@ -11,8 +11,8 @@ //! The ISAAC random number generator. use core::prelude::*; -use core::iter::{range_step, Repeat}; use core::slice; +use core::iter::{range_step, repeat}; use {Rng, SeedableRng, Rand}; @@ -205,7 +205,7 @@ impl<'a> SeedableRng<&'a [u32]> for IsaacRng { fn reseed(&mut self, seed: &'a [u32]) { // make the seed into [seed[0], seed[1], ..., seed[seed.len() // - 1], 0, 0, ...], to fill rng.rsl. - let seed_iter = seed.iter().map(|&x| x).chain(Repeat::new(0u32)); + let seed_iter = seed.iter().map(|&x| x).chain(repeat(0u32)); for (rsl_elem, seed_elem) in self.rsl.iter_mut().zip(seed_iter) { *rsl_elem = seed_elem; @@ -438,7 +438,7 @@ impl<'a> SeedableRng<&'a [u64]> for Isaac64Rng { fn reseed(&mut self, seed: &'a [u64]) { // make the seed into [seed[0], seed[1], ..., seed[seed.len() // - 1], 0, 0, ...], to fill rng.rsl. - let seed_iter = seed.iter().map(|&x| x).chain(Repeat::new(0u64)); + let seed_iter = seed.iter().map(|&x| x).chain(repeat(0u64)); for (rsl_elem, seed_elem) in self.rsl.iter_mut().zip(seed_iter) { *rsl_elem = seed_elem; diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs index 61c56cf9ecc..b42fb8ccc41 100644 --- a/src/librustc/middle/cfg/construct.rs +++ b/src/librustc/middle/cfg/construct.rs @@ -154,7 +154,6 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { pats: I, pred: CFGIndex) -> CFGIndex { //! Handles case where all of the patterns must match. - let mut pats = pats; pats.fold(pred, |pred, pat| self.pat(&**pat, pred)) } @@ -527,7 +526,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { } fn exprs<'a, I: Iterator<&'a ast::Expr>>(&mut self, - mut exprs: I, + exprs: I, pred: CFGIndex) -> CFGIndex { //! Constructs graph for `exprs` evaluated in order exprs.fold(pred, |p, e| self.expr(e, p)) diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index 806fea3b54f..bcfc003480f 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -93,7 +93,7 @@ impl<'a> fmt::Show for Matrix<'a> { } impl<'a> FromIterator<Vec<&'a Pat>> for Matrix<'a> { - fn from_iter<T: Iterator<Vec<&'a Pat>>>(mut iterator: T) -> Matrix<'a> { + fn from_iter<T: Iterator<Vec<&'a Pat>>>(iterator: T) -> Matrix<'a> { Matrix(iterator.collect()) } } @@ -1091,4 +1091,3 @@ impl<'a, 'b, 'tcx, 'v> Visitor<'v> for AtBindingPatternVisitor<'a, 'b, 'tcx> { } } } - diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 98ac7e413ca..7b442fedc24 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -80,7 +80,7 @@ pub fn join(a: constness, b: constness) -> constness { } } -pub fn join_all<It: Iterator<constness>>(mut cs: It) -> constness { +pub fn join_all<It: Iterator<constness>>(cs: It) -> constness { cs.fold(integral_const, |a, b| join(a, b)) } diff --git a/src/librustc/middle/dependency_format.rs b/src/librustc/middle/dependency_format.rs index e8e90e74989..3cb628c2e65 100644 --- a/src/librustc/middle/dependency_format.rs +++ b/src/librustc/middle/dependency_format.rs @@ -233,7 +233,7 @@ fn add_library(sess: &session::Session, fn attempt_static(sess: &session::Session) -> Option<DependencyList> { let crates = sess.cstore.get_used_crates(cstore::RequireStatic); - if crates.iter().all(|&(_, ref p)| p.is_some()) { + if crates.iter().by_ref().all(|&(_, ref p)| p.is_some()) { Some(crates.into_iter().map(|_| Some(cstore::RequireStatic)).collect()) } else { None diff --git a/src/librustc/middle/entry.rs b/src/librustc/middle/entry.rs index fd0162b30d8..417e5336249 100644 --- a/src/librustc/middle/entry.rs +++ b/src/librustc/middle/entry.rs @@ -80,7 +80,7 @@ fn find_item(item: &Item, ctxt: &mut EntryContext) { match item.node { ItemFn(..) => { if item.ident.name == ctxt.main_name { - ctxt.ast_map.with_path(item.id, |mut path| { + ctxt.ast_map.with_path(item.id, |path| { if path.count() == 1 { // This is a top-level function so can be 'main' if ctxt.main_fn.is_none() { diff --git a/src/librustc/middle/pat_util.rs b/src/librustc/middle/pat_util.rs index a51956797ca..8d4fbfd4cbc 100644 --- a/src/librustc/middle/pat_util.rs +++ b/src/librustc/middle/pat_util.rs @@ -132,7 +132,7 @@ pub fn simple_identifier<'a>(pat: &'a ast::Pat) -> Option<&'a ast::Ident> { } pub fn def_to_path(tcx: &ty::ctxt, id: ast::DefId) -> ast::Path { - ty::with_path(tcx, id, |mut path| ast::Path { + ty::with_path(tcx, id, |path| ast::Path { global: false, segments: path.last().map(|elem| ast::PathSegment { identifier: ast::Ident::new(elem.name()), diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 98b958749d5..2c8465e62d7 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -3106,7 +3106,7 @@ pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>) // Iterate until something non-representable is found fn find_nonrepresentable<'tcx, It: Iterator<Ty<'tcx>>>(cx: &ctxt<'tcx>, sp: Span, seen: &mut Vec<Ty<'tcx>>, - mut iter: It) + iter: It) -> Representability { iter.fold(Representable, |r, ty| cmp::max(r, is_type_structurally_recursive(cx, sp, seen, ty))) @@ -3164,7 +3164,7 @@ pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>) let types_a = substs_a.types.get_slice(subst::TypeSpace); let types_b = substs_b.types.get_slice(subst::TypeSpace); - let mut pairs = types_a.iter().zip(types_b.iter()); + let pairs = types_a.iter().zip(types_b.iter()); pairs.all(|(&a, &b)| same_type(a, b)) } diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index d38c5bc0ca9..754bdc8c8ea 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -4177,7 +4177,7 @@ fn check_expr_with_unifier<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, } ast::ExprMethodCall(ident, ref tps, ref args) => { check_method_call(fcx, expr, ident, args.as_slice(), tps.as_slice(), lvalue_pref); - let mut arg_tys = args.iter().map(|a| fcx.expr_ty(&**a)); + let arg_tys = args.iter().map(|a| fcx.expr_ty(&**a)); let args_err = arg_tys.fold(false, |rest_err, a| { rest_err || ty::type_is_error(a)}); diff --git a/src/librustc_trans/save/recorder.rs b/src/librustc_trans/save/recorder.rs index e245878dd87..2102133f97d 100644 --- a/src/librustc_trans/save/recorder.rs +++ b/src/librustc_trans/save/recorder.rs @@ -170,7 +170,7 @@ impl<'a> FmtStrs<'a> { }); let pairs = fields.iter().zip(values); - let mut strs = pairs.map(|(f, v)| format!(",{},\"{}\"", f, escape( + let strs = pairs.map(|(f, v)| format!(",{},\"{}\"", f, escape( if *f == "qualname" && v.len() > 0 { let mut n = self.krate.clone(); n.push_str("::"); diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index bdf2eca21d6..6fe5298393e 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -2696,7 +2696,7 @@ fn exported_name<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, id: ast::NodeId, // Use provided name Some(name) => name.get().to_string(), - _ => ccx.tcx().map.with_path(id, |mut path| { + _ => ccx.tcx().map.with_path(id, |path| { if attr::contains_name(attrs, "no_mangle") { // Don't mangle path.last().unwrap().to_string() diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs index 16edccd1543..a646b7e1ccb 100644 --- a/src/librustdoc/clean/inline.rs +++ b/src/librustdoc/clean/inline.rs @@ -151,7 +151,7 @@ pub fn build_external_trait(cx: &DocContext, tcx: &ty::ctxt, let def = ty::lookup_trait_def(tcx, did); let trait_items = ty::trait_items(tcx, did).clean(cx); let provided = ty::provided_trait_methods(tcx, did); - let mut items = trait_items.into_iter().map(|trait_item| { + let items = trait_items.into_iter().map(|trait_item| { if provided.iter().any(|a| a.def_id == trait_item.def_id) { clean::ProvidedMethod(trait_item) } else { diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index 43aef11ce5c..d523992b4c6 100644 --- a/src/librustdoc/html/format.rs +++ b/src/librustdoc/html/format.rs @@ -422,7 +422,7 @@ impl fmt::Show for clean::Type { bounds = if decl.bounds.len() == 0 { "".to_string() } else { - let mut m = decl.bounds + let m = decl.bounds .iter() .map(|s| s.to_string()); format!( diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs index 11dc8f4f660..df25daa3ca1 100644 --- a/src/librustdoc/html/markdown.rs +++ b/src/librustdoc/html/markdown.rs @@ -183,7 +183,7 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result { } }; - let mut lines = origtext.lines().filter(|l| { + let lines = origtext.lines().filter(|l| { stripped_filtered_line(*l).is_none() }); let text = lines.collect::<Vec<&str>>().connect("\n"); @@ -325,7 +325,7 @@ pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector) { let opaque = opaque as *mut hoedown_html_renderer_state; let tests = &mut *((*opaque).opaque as *mut ::test::Collector); let text = str::from_utf8(text).unwrap(); - let mut lines = text.lines().map(|l| { + let lines = text.lines().map(|l| { stripped_filtered_line(l).unwrap_or(l) }); let text = lines.collect::<Vec<&str>>().connect("\n"); diff --git a/src/librustrt/task.rs b/src/librustrt/task.rs index 63fa3938fc8..325bdc284ac 100644 --- a/src/librustrt/task.rs +++ b/src/librustrt/task.rs @@ -19,7 +19,7 @@ use alloc::arc::Arc; use alloc::boxed::Box; use core::any::Any; use core::atomic::{AtomicUint, SeqCst}; -use core::iter::Take; +use core::iter::{IteratorExt, Take}; use core::kinds::marker; use core::mem; use core::prelude::{Clone, Drop, Err, Iterator, None, Ok, Option, Send, Some}; diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs index 9754e673d38..403ca9d1432 100644 --- a/src/libstd/ascii.rs +++ b/src/libstd/ascii.rs @@ -17,7 +17,7 @@ use core::kinds::Sized; use fmt; -use iter::Iterator; +use iter::IteratorExt; use mem; use option::{Option, Some, None}; use slice::{SlicePrelude, AsSlice}; diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs index 662ae913764..9c7967d17bb 100644 --- a/src/libstd/collections/hash/map.rs +++ b/src/libstd/collections/hash/map.rs @@ -20,7 +20,7 @@ use cmp::{max, Eq, Equiv, PartialEq}; use default::Default; use fmt::{mod, Show}; use hash::{Hash, Hasher, RandomSipHasher}; -use iter::{mod, Iterator, FromIterator, Extend}; +use iter::{mod, Iterator, IteratorExt, FromIterator, Extend}; use kinds::Sized; use mem::{mod, replace}; use num::UnsignedInt; diff --git a/src/libstd/collections/hash/set.rs b/src/libstd/collections/hash/set.rs index 2fbcb464358..f6d526cca39 100644 --- a/src/libstd/collections/hash/set.rs +++ b/src/libstd/collections/hash/set.rs @@ -17,7 +17,7 @@ use default::Default; use fmt::Show; use fmt; use hash::{Hash, Hasher, RandomSipHasher}; -use iter::{Iterator, FromIterator, FilterMap, Chain, Repeat, Zip, Extend}; +use iter::{Iterator, IteratorExt, FromIterator, FilterMap, Chain, Repeat, Zip, Extend, repeat}; use iter; use option::{Some, None}; use result::{Ok, Err}; @@ -262,7 +262,7 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> { /// ``` #[unstable = "matches collection reform specification, waiting for dust to settle"] pub fn difference<'a>(&'a self, other: &'a HashSet<T, H>) -> SetAlgebraItems<'a, T, H> { - Repeat::new(other).zip(self.iter()) + repeat(other).zip(self.iter()) .filter_map(|(other, elt)| { if !other.contains(elt) { Some(elt) } else { None } }) @@ -314,7 +314,7 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> { #[unstable = "matches collection reform specification, waiting for dust to settle"] pub fn intersection<'a>(&'a self, other: &'a HashSet<T, H>) -> SetAlgebraItems<'a, T, H> { - Repeat::new(other).zip(self.iter()) + repeat(other).zip(self.iter()) .filter_map(|(other, elt)| { if other.contains(elt) { Some(elt) } else { None } }) diff --git a/src/libstd/dynamic_lib.rs b/src/libstd/dynamic_lib.rs index 0f119d44485..4b868f6a95b 100644 --- a/src/libstd/dynamic_lib.rs +++ b/src/libstd/dynamic_lib.rs @@ -21,7 +21,7 @@ A simple wrapper over the platform's dynamic library facilities use clone::Clone; use c_str::ToCStr; -use iter::Iterator; +use iter::IteratorExt; use mem; use ops::*; use option::*; @@ -280,7 +280,7 @@ pub mod dl { #[cfg(target_os = "windows")] pub mod dl { use c_str::ToCStr; - use iter::Iterator; + use iter::IteratorExt; use libc; use os; use ptr; diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs index 148323762c8..025033a112c 100644 --- a/src/libstd/io/buffered.rs +++ b/src/libstd/io/buffered.rs @@ -14,7 +14,7 @@ use cmp; use io::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult}; -use iter::ExactSize; +use iter::ExactSizeIterator; use ops::Drop; use option::{Some, None, Option}; use result::{Ok, Err}; diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index 681400e9db5..a25674030ae 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -233,7 +233,7 @@ use default::Default; use error::{FromError, Error}; use fmt; use int; -use iter::Iterator; +use iter::{Iterator, IteratorExt}; use mem::transmute; use ops::{BitOr, BitXor, BitAnd, Sub, Not}; use option::{Option, Some, None}; diff --git a/src/libstd/io/net/addrinfo.rs b/src/libstd/io/net/addrinfo.rs index 13f602de03a..d6a48fd39e6 100644 --- a/src/libstd/io/net/addrinfo.rs +++ b/src/libstd/io/net/addrinfo.rs @@ -23,7 +23,7 @@ pub use self::SocketType::*; pub use self::Flag::*; pub use self::Protocol::*; -use iter::Iterator; +use iter::IteratorExt; use io::{IoResult}; use io::net::ip::{SocketAddr, IpAddr}; use option::{Option, Some, None}; diff --git a/src/libstd/io/net/ip.rs b/src/libstd/io/net/ip.rs index d87768a0860..4812e911cc4 100644 --- a/src/libstd/io/net/ip.rs +++ b/src/libstd/io/net/ip.rs @@ -20,7 +20,7 @@ pub use self::IpAddr::*; use fmt; use io::{mod, IoResult, IoError}; use io::net; -use iter::Iterator; +use iter::{Iterator, IteratorExt}; use option::{Option, None, Some}; use result::{Ok, Err}; use str::{FromStr, StrPrelude}; diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs index a989be758c3..aa223417591 100644 --- a/src/libstd/io/net/tcp.rs +++ b/src/libstd/io/net/tcp.rs @@ -19,7 +19,6 @@ use clone::Clone; use io::IoResult; -use iter::Iterator; use result::Err; use io::net::ip::{SocketAddr, ToSocketAddr}; use io::{Reader, Writer, Listener, Acceptor}; diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs index d450e9f1dce..e6dd20f63fb 100644 --- a/src/libstd/io/stdio.rs +++ b/src/libstd/io/stdio.rs @@ -35,7 +35,6 @@ use failure::LOCAL_STDERR; use fmt; use io::{Reader, Writer, IoResult, IoError, OtherIoError, standard_error, EndOfFile, LineBufferedWriter, BufferedReader}; -use iter::Iterator; use kinds::Send; use libc; use mem; diff --git a/src/libstd/os.rs b/src/libstd/os.rs index 33c9f38da9b..6b5ec983a80 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -39,7 +39,7 @@ use clone::Clone; use error::{FromError, Error}; use fmt; use io::{IoResult, IoError}; -use iter::Iterator; +use iter::{Iterator, IteratorExt}; use libc::{c_void, c_int}; use libc; use boxed::Box; diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs index ce3440ead40..047fa51b92f 100644 --- a/src/libstd/path/mod.rs +++ b/src/libstd/path/mod.rs @@ -71,7 +71,7 @@ use core::kinds::Sized; use c_str::CString; use clone::Clone; use fmt; -use iter::Iterator; +use iter::IteratorExt; use option::{Option, None, Some}; use str; use str::{CowString, MaybeOwned, Str, StrPrelude}; diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs index bdce759a1df..cc8fcccf14a 100644 --- a/src/libstd/path/posix.rs +++ b/src/libstd/path/posix.rs @@ -15,9 +15,10 @@ use clone::Clone; use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering}; use hash; use io::Writer; -use iter::{DoubleEndedIterator, AdditiveIterator, Extend, Iterator, Map}; -use kinds::Sized; +use iter::{DoubleEndedIteratorExt, AdditiveIterator, Extend}; +use iter::{Iterator, IteratorExt, Map}; use option::{Option, None, Some}; +use kinds::Sized; use str::{FromStr, Str}; use str; use slice::{CloneSliceAllocPrelude, Splits, AsSlice, VectorVector, diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs index fc367710131..6a6551af499 100644 --- a/src/libstd/path/windows.rs +++ b/src/libstd/path/windows.rs @@ -20,7 +20,8 @@ use clone::Clone; use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering}; use hash; use io::Writer; -use iter::{AdditiveIterator, DoubleEndedIterator, Extend, Iterator, Map}; +use iter::{AdditiveIterator, DoubleEndedIteratorExt, Extend}; +use iter::{Iterator, IteratorExt, Map}; use mem; use option::{Option, Some, None}; use slice::{AsSlice, SlicePrelude}; diff --git a/src/libstd/prelude.rs b/src/libstd/prelude.rs index 756ff1c58f3..590a7894fa7 100644 --- a/src/libstd/prelude.rs +++ b/src/libstd/prelude.rs @@ -50,7 +50,7 @@ #[doc(no_inline)] pub use ops::{Fn, FnMut, FnOnce}; // Reexported functions -#[doc(no_inline)] pub use iter::{range, repeat}; +#[doc(no_inline)] pub use iter::range; #[doc(no_inline)] pub use mem::drop; #[doc(no_inline)] pub use str::from_str; @@ -65,10 +65,11 @@ #[doc(no_inline)] pub use cmp::{PartialEq, PartialOrd, Eq, Ord}; #[doc(no_inline)] pub use cmp::{Ordering, Equiv}; #[doc(no_inline)] pub use cmp::Ordering::{Less, Equal, Greater}; -#[doc(no_inline)] pub use iter::{FromIterator, Extend, ExactSize}; -#[doc(no_inline)] pub use iter::{Iterator, DoubleEndedIterator}; -#[doc(no_inline)] pub use iter::{RandomAccessIterator, CloneableIterator}; -#[doc(no_inline)] pub use iter::{OrdIterator, MutableDoubleEndedIterator}; +#[doc(no_inline)] pub use iter::{FromIterator, Extend, ExactSizeIterator}; +#[doc(no_inline)] pub use iter::{Iterator, IteratorExt, DoubleEndedIterator}; +#[doc(no_inline)] pub use iter::{DoubleEndedIteratorExt, CloneIteratorExt}; +#[doc(no_inline)] pub use iter::{RandomAccessIterator, IteratorCloneExt}; +#[doc(no_inline)] pub use iter::{IteratorOrdExt, MutableDoubleEndedIterator}; #[doc(no_inline)] pub use num::{ToPrimitive, FromPrimitive}; #[doc(no_inline)] pub use boxed::Box; #[doc(no_inline)] pub use option::Option; diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs index f9f9147b107..da690f5d154 100644 --- a/src/libstd/rand/mod.rs +++ b/src/libstd/rand/mod.rs @@ -224,7 +224,7 @@ use cell::RefCell; use clone::Clone; use io::IoResult; -use iter::Iterator; +use iter::{Iterator, IteratorExt}; use mem; use rc::Rc; use result::{Ok, Err}; diff --git a/src/libstd/rt/backtrace.rs b/src/libstd/rt/backtrace.rs index 81022994387..4f6c1f8a2c6 100644 --- a/src/libstd/rt/backtrace.rs +++ b/src/libstd/rt/backtrace.rs @@ -13,7 +13,7 @@ #![allow(non_camel_case_types)] use io::{IoResult, Writer}; -use iter::Iterator; +use iter::{Iterator, IteratorExt}; use option::{Some, None}; use os; use result::{Ok, Err}; @@ -388,7 +388,7 @@ mod imp { #[cfg(not(any(target_os = "macos", target_os = "ios")))] fn print(w: &mut Writer, idx: int, addr: *mut libc::c_void) -> IoResult<()> { - use iter::Iterator; + use iter::IteratorExt; use os; use path::GenericPath; use ptr::RawPtr; diff --git a/src/libstd/sys/windows/c.rs b/src/libstd/sys/windows/c.rs index b8e9b1dca3a..e46765f25b8 100644 --- a/src/libstd/sys/windows/c.rs +++ b/src/libstd/sys/windows/c.rs @@ -131,7 +131,7 @@ extern "system" { pub mod compat { use intrinsics::{atomic_store_relaxed, transmute}; - use iter::Iterator; + use iter::IteratorExt; use libc::types::os::arch::extra::{LPCWSTR, HMODULE, LPCSTR, LPVOID}; use prelude::*; diff --git a/src/libstd/sys/windows/process.rs b/src/libstd/sys/windows/process.rs index eddb89c673d..7d0151a7b6b 100644 --- a/src/libstd/sys/windows/process.rs +++ b/src/libstd/sys/windows/process.rs @@ -124,7 +124,7 @@ impl Process { use libc::funcs::extra::msvcrt::get_osfhandle; use mem; - use iter::Iterator; + use iter::{Iterator, IteratorExt}; use str::StrPrelude; if cfg.gid().is_some() || cfg.uid().is_some() { diff --git a/src/libsyntax/ast_map/mod.rs b/src/libsyntax/ast_map/mod.rs index 8a2202d28d5..6b97b931ef7 100644 --- a/src/libsyntax/ast_map/mod.rs +++ b/src/libsyntax/ast_map/mod.rs @@ -87,7 +87,7 @@ impl<'a, T: Copy> Iterator<T> for Values<'a, T> { /// The type of the iterator used by with_path. pub type PathElems<'a, 'b> = iter::Chain<Values<'a, PathElem>, LinkedPath<'b>>; -pub fn path_to_string<PI: Iterator<PathElem>>(mut path: PI) -> String { +pub fn path_to_string<PI: Iterator<PathElem>>(path: PI) -> String { let itr = token::get_ident_interner(); path.fold(String::new(), |mut s, e| { diff --git a/src/libsyntax/config.rs b/src/libsyntax/config.rs index 257bfd69f43..4f718555d53 100644 --- a/src/libsyntax/config.rs +++ b/src/libsyntax/config.rs @@ -131,7 +131,7 @@ fn fold_item_underscore(cx: &mut Context, item: ast::Item_) -> ast::Item_ { ast::ItemStruct(fold_struct(cx, def), generics) } ast::ItemEnum(def, generics) => { - let mut variants = def.variants.into_iter().filter_map(|v| { + let variants = def.variants.into_iter().filter_map(|v| { if !(cx.in_cfg)(v.node.attrs.as_slice()) { None } else { @@ -273,4 +273,3 @@ fn in_cfg(diagnostic: &SpanHandler, cfg: &[P<ast::MetaItem>], attrs: &[ast::Attr attr::cfg_matches(diagnostic, cfg, &*mis[0]) }) } - diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 1cbc2b98c93..8d0d399fa31 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -210,7 +210,7 @@ pub struct MacItems { } impl MacItems { - pub fn new<I: Iterator<P<ast::Item>>>(mut it: I) -> Box<MacResult+'static> { + pub fn new<I: Iterator<P<ast::Item>>>(it: I) -> Box<MacResult+'static> { box MacItems { items: it.collect() } as Box<MacResult+'static> } } diff --git a/src/libsyntax/ext/format.rs b/src/libsyntax/ext/format.rs index b04a800a32d..490246f8246 100644 --- a/src/libsyntax/ext/format.rs +++ b/src/libsyntax/ext/format.rs @@ -580,7 +580,7 @@ impl<'a, 'b> Context<'a, 'b> { let slicename = self.ecx.ident_of("__args_vec"); { let args = names.into_iter().map(|a| a.unwrap()); - let mut args = locals.into_iter().chain(args); + let args = locals.into_iter().chain(args); let args = self.ecx.expr_vec_slice(self.fmtsp, args.collect()); lets.push(self.ecx.stmt_let(self.fmtsp, false, slicename, args)); } diff --git a/src/libsyntax/owned_slice.rs b/src/libsyntax/owned_slice.rs index f622e2d6112..b31b20c80c2 100644 --- a/src/libsyntax/owned_slice.rs +++ b/src/libsyntax/owned_slice.rs @@ -145,7 +145,7 @@ impl<T: PartialEq> PartialEq for OwnedSlice<T> { impl<T: Eq> Eq for OwnedSlice<T> {} impl<T> FromIterator<T> for OwnedSlice<T> { - fn from_iter<I: Iterator<T>>(mut iter: I) -> OwnedSlice<T> { + fn from_iter<I: Iterator<T>>(iter: I) -> OwnedSlice<T> { OwnedSlice::from_vec(iter.collect()) } } diff --git a/src/libunicode/u_str.rs b/src/libunicode/u_str.rs index 56b1f0907d5..03a50409d7e 100644 --- a/src/libunicode/u_str.rs +++ b/src/libunicode/u_str.rs @@ -20,7 +20,8 @@ use self::GraphemeState::*; use core::cmp; use core::slice::SlicePrelude; -use core::iter::{Filter, AdditiveIterator, Iterator, DoubleEndedIterator}; +use core::iter::{Filter, AdditiveIterator, Iterator, IteratorExt}; +use core::iter::{DoubleEndedIterator, DoubleEndedIteratorExt}; use core::kinds::Sized; use core::option::{Option, None, Some}; use core::str::{CharSplits, StrPrelude}; |