From a86f72d9a2adc6d65f2ba0990caca35c1a3f622d Mon Sep 17 00:00:00 2001 From: Aaron Turon Date: Thu, 6 Nov 2014 09:32:32 -0800 Subject: [PATCH 1/2] libs: stabilize iter module This is an initial pass at stabilizing the `iter` module. The module is fairly large, but is also pretty polished, so most of the stabilization leaves things as they are. Some changes: * Due to the new object safety rules, various traits needs to be split into object-safe traits and extension traits. This includes `Iterator` itself. While splitting up the traits adds some complexity, it will also increase flexbility: once we have automatic impls of `Trait` for trait objects over `Trait`, then things like the iterator adapters will all work with trait objects. * Iterator adapters that use up the entire iterator now take it by value, which makes the semantics more clear and helps catch bugs. Due to the splitting of Iterator, this does not affect trait objects. If the underlying iterator is still desired for some reason, `by_ref` can be used. (Note: this change had no fallout in the Rust distro except for the useless mut lint.) * In general, extension traits new and old are following an [in-progress convention](https://github.com/rust-lang/rfcs/pull/445). As such, they are marked `unstable`. * As usual, anything involving closures is `unstable` pending unboxed closures. * A few of the more esoteric/underdeveloped iterator forms (like `RandomAccessIterator` and `MutableDoubleEndedIterator`, along with various unfolds) are left experimental for now. * The `order` submodule is left `experimental` because it will hopefully be replaced by generalized comparison traits. * "Leaf" iterators (like `Repeat` and `Counter`) are uniformly constructed by free fns at the module level. That's because the types are not otherwise of any significance (if we had `impl Trait`, you wouldn't want to define a type at all). Closes #17701 Due to renamings and splitting of traits, this is a: [breaking-change] --- src/libcore/iter.rs | 243 ++++++++++++++++++++++++++++++++++++-------- 1 file changed, 199 insertions(+), 44 deletions(-) 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 { /// Build a container with elements from an external iterator. fn from_iter>(iterator: T) -> Self; } /// A type growable from an `Iterator` implementation +#[unstable = "just renamed as part of collections reform"] pub trait Extend { /// Extend a container with the elements yielded by an arbitrary iterator fn extend>(&mut self, iterator: T); @@ -94,6 +96,7 @@ pub trait Extend { /// it wishes, either by returning `None` infinitely, or by doing something /// else. #[lang="iterator"] +#[unstable = "just split up for object safety"] pub trait Iterator { /// Advance the iterator and return the next value. Return `None` when the end is reached. fn next(&mut self) -> Option; @@ -104,7 +107,11 @@ pub trait Iterator { /// does not fit within a `uint`. #[inline] fn size_hint(&self) -> (uint, Option) { (0, None) } +} +#[unstable = "new convention for extension traits"] +/// An extension trait providing numerous methods applicable to all iterators. +pub trait IteratorExt: Iterator { /// 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 { /// assert!(it.next().is_none()); /// ``` #[inline] + #[stable] fn chain>(self, other: U) -> Chain { Chain{a: self, b: other, flag: false} } @@ -140,6 +148,7 @@ pub trait Iterator { /// assert!(it.next().is_none()); /// ``` #[inline] + #[stable] fn zip>(self, other: U) -> Zip { Zip{a: self, b: other} } @@ -157,6 +166,7 @@ pub trait Iterator { /// 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 { /// 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 { /// assert!(it.next().is_none()); /// ``` #[inline] + #[unstable = "waiting for unboxed closures"] fn filter_map<'r, B>(self, f: |A|: 'r -> Option) -> FilterMap<'r, A, B, Self> { FilterMap { iter: self, f: f } } @@ -209,6 +221,7 @@ pub trait Iterator { /// assert!(it.next().is_none()); /// ``` #[inline] + #[stable] fn enumerate(self) -> Enumerate { Enumerate{iter: self, count: 0} } @@ -232,6 +245,7 @@ pub trait Iterator { /// assert!(it.next().is_none()); /// ``` #[inline] + #[stable] fn peekable(self) -> Peekable { Peekable{iter: self, peeked: None} } @@ -251,6 +265,7 @@ pub trait Iterator { /// 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 { /// 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 { /// assert!(it.next().is_none()); /// ``` #[inline] + #[stable] fn skip(self, n: uint) -> Skip { Skip{iter: self, n: n} } @@ -304,6 +321,7 @@ pub trait Iterator { /// assert!(it.next().is_none()); /// ``` #[inline] + #[stable] fn take(self, n: uint) -> Take { Take{iter: self, n: n} } @@ -329,6 +347,7 @@ pub trait Iterator { /// 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) -> Scan<'r, A, B, Self, St> { Scan{iter: self, f: f, state: initial_state} @@ -353,6 +372,7 @@ pub trait Iterator { /// } /// ``` #[inline] + #[unstable = "waiting for unboxed closures"] fn flat_map<'r, B, U: Iterator>(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 { /// assert_eq!(process(x.into_iter()), 1006); /// ``` #[inline] + #[stable] fn fuse(self) -> Fuse { Fuse{iter: self, done: false} } @@ -409,6 +430,7 @@ pub trait Iterator { /// 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 { /// // 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 { /// assert!(a.as_slice() == b.as_slice()); /// ``` #[inline] - fn collect>(&mut self) -> B { - FromIterator::from_iter(self.by_ref()) + #[unstable = "waiting for general conversion traits, just changed to take self by value"] + fn collect>(self) -> B { + FromIterator::from_iter(self) } /// Loops through `n` iterations, returning the `n`th element of the @@ -459,6 +483,7 @@ pub trait Iterator { /// assert!(it.nth(2) == None); /// ``` #[inline] + #[stable] fn nth(&mut self, mut n: uint) -> Option { for x in *self { if n == 0 { return Some(x) } @@ -477,9 +502,10 @@ pub trait Iterator { /// assert!(a.iter().last().unwrap() == &5); /// ``` #[inline] - fn last(&mut self) -> Option { + #[unstable = "just changed to take self by value"] + fn last(mut self) -> Option { 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 { /// assert!(a.iter().fold(0, |a, &b| a + b) == 15); /// ``` #[inline] - fn fold(&mut self, init: B, f: |B, A| -> B) -> B { + #[unstable = "waiting for unboxed closures, just changed to take self by value"] + fn fold(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 { /// 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 { /// 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 { /// 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 { /// /// Does not consume the iterator past the first found element. #[inline] + #[unstable = "waiting for unboxed closures"] fn find(&mut self, predicate: |&A| -> bool) -> Option { for x in *self { if predicate(&x) { return Some(x) } @@ -561,6 +591,7 @@ pub trait Iterator { /// 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 { let mut i = 0; for x in *self { @@ -584,7 +615,8 @@ pub trait Iterator { /// assert_eq!(*xs.iter().max_by(|x| x.abs()).unwrap(), -10); /// ``` #[inline] - fn max_by(&mut self, f: |&A| -> B) -> Option { + #[unstable = "waiting for unboxed closures, just changed to take self by value"] + fn max_by(self, f: |&A| -> B) -> Option { self.fold(None, |max: Option<(A, B)>, x| { let x_val = f(&x); match max { @@ -610,7 +642,8 @@ pub trait Iterator { /// assert_eq!(*xs.iter().min_by(|x| x.abs()).unwrap(), 0); /// ``` #[inline] - fn min_by(&mut self, f: |&A| -> B) -> Option { + #[unstable = "waiting for unboxed closures, just changed to take self by value"] + fn min_by(self, f: |&A| -> B) -> Option { self.fold(None, |min: Option<(A, B)>, x| { let x_val = f(&x); match min { @@ -625,14 +658,22 @@ pub trait Iterator { } } +#[unstable = "trait is unstable"] +impl IteratorExt for I where I: Iterator {} + /// 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: Iterator { /// Yield an element from the end of the range, returning `None` if the range is empty. fn next_back(&mut self) -> Option; +} +/// Extension methods for double-ended iterators. +#[unstable = "new extension trait convention"] +pub trait DoubleEndedIteratorExt: DoubleEndedIterator { /// 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: Iterator { /// 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 { Rev{iter: self} } } +#[unstable = "trait is unstable"] +impl DoubleEndedIteratorExt for I where I: DoubleEndedIterator {} + /// 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: Iterator { /// 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: Iterator { /// /// `Iterator::size_hint` *must* return the exact size of the iterator. /// Note that the size must fit in `uint`. -pub trait ExactSize : DoubleEndedIterator { +#[unstable = "could move DoubleEndedIterator bound onto rposition with method-level where clauses"] +pub trait ExactSizeIterator : DoubleEndedIterator { /// 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 : DoubleEndedIterator { fn rposition(&mut self, predicate: |A| -> bool) -> Option { 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 : DoubleEndedIterator { // 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> ExactSize<(uint, A)> for Enumerate {} -impl<'a, A, T: ExactSize> ExactSize for Inspect<'a, A, T> {} -impl> ExactSize for Rev {} -impl<'a, A, B, T: ExactSize> ExactSize for Map<'a, A, B, T> {} -impl, U: ExactSize> ExactSize<(A, B)> for Zip {} +#[unstable = "trait is unstable"] +impl> ExactSizeIterator<(uint, A)> for Enumerate {} +#[unstable = "trait is unstable"] +impl<'a, A, T: ExactSizeIterator> ExactSizeIterator for Inspect<'a, A, T> {} +#[unstable = "trait is unstable"] +impl> ExactSizeIterator for Rev {} +#[unstable = "trait is unstable"] +impl<'a, A, B, T: ExactSizeIterator> ExactSizeIterator for Map<'a, A, B, T> {} +#[unstable = "trait is unstable"] +impl ExactSizeIterator<(A, B)> for Zip + where T: ExactSizeIterator, U: ExactSizeIterator {} /// 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 { iter: T } +#[unstable = "trait is unstable"] impl> Iterator for Rev { #[inline] fn next(&mut self) -> Option { self.iter.next_back() } @@ -744,11 +801,13 @@ impl> Iterator for Rev { fn size_hint(&self) -> (uint, Option) { self.iter.size_hint() } } +#[unstable = "trait is unstable"] impl> DoubleEndedIterator for Rev { #[inline] fn next_back(&mut self) -> Option { self.iter.next() } } +#[experimental = "trait is experimental"] impl + RandomAccessIterator> RandomAccessIterator for Rev { #[inline] @@ -762,10 +821,12 @@ impl + RandomAccessIterator> 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> Iterator for ByRef<'a, T> { #[inline] fn next(&mut self) -> Option { self.iter.next() } @@ -773,12 +834,14 @@ impl<'a, A, T: Iterator+'a> Iterator for ByRef<'a, T> { fn size_hint(&self) -> (uint, Option) { self.iter.size_hint() } } +#[unstable = "trait is unstable"] impl<'a, A, T: DoubleEndedIterator+'a> DoubleEndedIterator for ByRef<'a, T> { #[inline] fn next_back(&mut self) -> Option { 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 { /// Iterates over the entire iterator, summing up all the elements /// @@ -791,14 +854,15 @@ pub trait AdditiveIterator { /// 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> 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 { /// Iterates over the entire iterator, multiplying all the elements /// @@ -833,14 +898,15 @@ pub trait MultiplicativeIterator { /// 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> 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 { +#[unstable = "recently renamed for new extension trait conventions"] +pub trait IteratorOrdExt { /// Consumes the entire iterator to return the maximum element. /// /// # Example @@ -869,7 +936,7 @@ pub trait OrdIterator { /// let a = [1i, 2, 3, 4, 5]; /// assert!(a.iter().max().unwrap() == &5); /// ``` - fn max(&mut self) -> Option; + fn max(self) -> Option; /// Consumes the entire iterator to return the minimum element. /// @@ -879,7 +946,7 @@ pub trait OrdIterator { /// let a = [1i, 2, 3, 4, 5]; /// assert!(a.iter().min().unwrap() == &1); /// ``` - fn min(&mut self) -> Option; + fn min(self) -> Option; /// `min_max` finds the minimum and maximum elements in the iterator. /// @@ -914,12 +981,13 @@ pub trait OrdIterator { /// let v = [1i, 1, 1, 1]; /// assert!(v.iter().min_max() == MinMax(&1, &1)); /// ``` - fn min_max(&mut self) -> MinMaxResult; + fn min_max(self) -> MinMaxResult; } -impl> OrdIterator for T { +#[unstable = "trait is unstable"] +impl> IteratorOrdExt for T { #[inline] - fn max(&mut self) -> Option { + fn max(self) -> Option { self.fold(None, |max, x| { match max { None => Some(x), @@ -929,7 +997,7 @@ impl> OrdIterator for T { } #[inline] - fn min(&mut self) -> Option { + fn min(self) -> Option { self.fold(None, |min, x| { match min { None => Some(x), @@ -938,7 +1006,7 @@ impl> OrdIterator for T { }) } - fn min_max(&mut self) -> MinMaxResult { + fn min_max(mut self) -> MinMaxResult { let (mut min, mut max) = match self.next() { None => return NoElements, Some(x) => { @@ -982,8 +1050,9 @@ impl> OrdIterator 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 { /// Empty iterator NoElements, @@ -995,6 +1064,7 @@ pub enum MinMaxResult { MinMax(T, T) } +#[stable] impl MinMaxResult { /// `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 MinMaxResult { } /// A trait for iterators that contain cloneable elements -pub trait CloneIteratorExt { +#[unstable = "recently renamed for extension trait conventions"] +pub trait IteratorCloneExt { /// Creates an iterator that clones the elements it yields. Useful for converting an /// Iterator<&T> to an Iterator. fn cloned(self) -> Cloned; } - -impl, I: Iterator> CloneIteratorExt for I { +#[unstable = "trait is unstable"] +impl, I: Iterator> IteratorCloneExt for I { fn cloned(self) -> Cloned { Cloned { it: self } } @@ -1060,28 +1131,31 @@ impl, I: DoubleEndedIterator> } } -impl, I: ExactSize> ExactSize for Cloned {} +#[unstable = "trait is unstable"] +impl, I: ExactSizeIterator> ExactSizeIterator for Cloned {} -/// 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; } -impl> CloneableIterator for T { +impl CloneIteratorExt for I where I: Iterator + Clone { #[inline] - fn cycle(self) -> Cycle { + fn cycle(self) -> Cycle { Cycle{orig: self.clone(), iter: self} } } @@ -1089,11 +1163,13 @@ impl> 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 { orig: T, iter: T, } +#[unstable = "trait is unstable"] impl> Iterator for Cycle { #[inline] fn next(&mut self) -> Option { @@ -1114,6 +1190,7 @@ impl> Iterator for Cycle { } } +#[experimental = "trait is experimental"] impl> RandomAccessIterator for Cycle { #[inline] fn indexable(&self) -> uint { @@ -1141,12 +1218,14 @@ impl> RandomAccessIterator for Cycle /// An iterator which strings two iterators together #[deriving(Clone)] #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] +#[stable] pub struct Chain { a: T, b: U, flag: bool, } +#[unstable = "trait is unstable"] impl, U: Iterator> Iterator for Chain { #[inline] fn next(&mut self) -> Option { @@ -1178,6 +1257,7 @@ impl, U: Iterator> Iterator for Chain { } } +#[unstable = "trait is unstable"] impl, U: DoubleEndedIterator> DoubleEndedIterator for Chain { #[inline] @@ -1189,6 +1269,7 @@ for Chain { } } +#[experimental = "trait is experimental"] impl, U: RandomAccessIterator> RandomAccessIterator for Chain { #[inline] @@ -1211,11 +1292,13 @@ for Chain { /// 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 { a: T, b: U } +#[unstable = "trait is unstable"] impl, U: Iterator> Iterator<(A, B)> for Zip { #[inline] fn next(&mut self) -> Option<(A, B)> { @@ -1246,7 +1329,8 @@ impl, U: Iterator> Iterator<(A, B)> for Zip { } } -impl, U: ExactSize> DoubleEndedIterator<(A, B)> +#[unstable = "trait is unstable"] +impl, U: ExactSizeIterator> DoubleEndedIterator<(A, B)> for Zip { #[inline] fn next_back(&mut self) -> Option<(A, B)> { @@ -1268,6 +1352,7 @@ for Zip { } } +#[experimental = "trait is experimental"] impl, U: RandomAccessIterator> RandomAccessIterator<(A, B)> for Zip { #[inline] @@ -1289,6 +1374,7 @@ RandomAccessIterator<(A, B)> for Zip { /// 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> Iterator for Map<'a, A, B, T> { #[inline] fn next(&mut self) -> Option { @@ -1317,6 +1404,7 @@ impl<'a, A, B, T: Iterator> Iterator for Map<'a, A, B, T> { } } +#[unstable = "trait is unstable"] impl<'a, A, B, T: DoubleEndedIterator> DoubleEndedIterator for Map<'a, A, B, T> { #[inline] fn next_back(&mut self) -> Option { @@ -1325,6 +1413,7 @@ impl<'a, A, B, T: DoubleEndedIterator> DoubleEndedIterator for Map<'a, A, } } +#[experimental = "trait is experimental"] impl<'a, A, B, T: RandomAccessIterator> RandomAccessIterator for Map<'a, A, B, T> { #[inline] fn indexable(&self) -> uint { @@ -1340,11 +1429,13 @@ impl<'a, A, B, T: RandomAccessIterator> RandomAccessIterator 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> Iterator for Filter<'a, A, T> { #[inline] fn next(&mut self) -> Option { @@ -1365,6 +1456,7 @@ impl<'a, A, T: Iterator> Iterator for Filter<'a, A, T> { } } +#[unstable = "trait is unstable"] impl<'a, A, T: DoubleEndedIterator> DoubleEndedIterator for Filter<'a, A, T> { #[inline] fn next_back(&mut self) -> Option { @@ -1379,11 +1471,13 @@ impl<'a, A, T: DoubleEndedIterator> DoubleEndedIterator 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 } +#[unstable = "trait is unstable"] impl<'a, A, B, T: Iterator> Iterator for FilterMap<'a, A, B, T> { #[inline] fn next(&mut self) -> Option { @@ -1403,6 +1497,7 @@ impl<'a, A, B, T: Iterator> Iterator for FilterMap<'a, A, B, T> { } } +#[unstable = "trait is unstable"] impl<'a, A, B, T: DoubleEndedIterator> DoubleEndedIterator 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 { iter: T, count: uint } +#[unstable = "trait is unstable"] impl> Iterator<(uint, A)> for Enumerate { #[inline] fn next(&mut self) -> Option<(uint, A)> { @@ -1444,7 +1541,8 @@ impl> Iterator<(uint, A)> for Enumerate { } } -impl> DoubleEndedIterator<(uint, A)> for Enumerate { +#[unstable = "trait is unstable"] +impl> DoubleEndedIterator<(uint, A)> for Enumerate { #[inline] fn next_back(&mut self) -> Option<(uint, A)> { match self.iter.next_back() { @@ -1457,6 +1555,7 @@ impl> DoubleEndedIterator<(uint, A)> for Enumerate { } } +#[experimental = "trait is experimental"] impl> RandomAccessIterator<(uint, A)> for Enumerate { #[inline] fn indexable(&self) -> uint { @@ -1474,11 +1573,13 @@ impl> 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 { iter: T, peeked: Option, } +#[unstable = "trait is unstable"] impl> Iterator for Peekable { #[inline] fn next(&mut self) -> Option { @@ -1502,6 +1603,7 @@ impl> Iterator for Peekable { } } +#[stable] impl<'a, A, T: Iterator> Peekable { /// 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> Peekable { /// 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> Iterator for SkipWhile<'a, A, T> { #[inline] fn next(&mut self) -> Option { @@ -1552,12 +1656,14 @@ impl<'a, A, T: Iterator> Iterator 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> Iterator for TakeWhile<'a, A, T> { #[inline] fn next(&mut self) -> Option { @@ -1588,11 +1694,13 @@ impl<'a, A, T: Iterator> Iterator 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 { iter: T, n: uint } +#[unstable = "trait is unstable"] impl> Iterator for Skip { #[inline] fn next(&mut self) -> Option { @@ -1634,6 +1742,7 @@ impl> Iterator for Skip { } } +#[experimental = "trait is experimental"] impl> RandomAccessIterator for Skip { #[inline] fn indexable(&self) -> uint { @@ -1653,11 +1762,13 @@ impl> RandomAccessIterator for Skip { /// 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 { iter: T, n: uint } +#[unstable = "trait is unstable"] impl> Iterator for Take { #[inline] fn next(&mut self) -> Option { @@ -1684,6 +1795,7 @@ impl> Iterator for Take { } } +#[experimental = "trait is experimental"] impl> RandomAccessIterator for Take { #[inline] fn indexable(&self) -> uint { @@ -1703,6 +1815,7 @@ impl> RandomAccessIterator for Take { /// 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, @@ -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, St> Iterator for Scan<'a, A, B, T, St> { #[inline] fn next(&mut self) -> Option { @@ -1728,6 +1842,7 @@ impl<'a, A, B, T: Iterator, St> Iterator 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, } +#[unstable = "trait is unstable"] impl<'a, A, T: Iterator, B, U: Iterator> Iterator for FlatMap<'a, A, T, U> { #[inline] fn next(&mut self) -> Option { @@ -1763,6 +1879,7 @@ impl<'a, A, T: Iterator, B, U: Iterator> Iterator for FlatMap<'a, A, T, } } +#[unstable = "trait is unstable"] impl<'a, A, T: DoubleEndedIterator, B, U: DoubleEndedIterator> DoubleEndedIterator @@ -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 { iter: T, done: bool } +#[unstable = "trait is unstable"] impl> Iterator for Fuse { #[inline] fn next(&mut self) -> Option { @@ -1819,6 +1938,7 @@ impl> Iterator for Fuse { } } +#[unstable = "trait is unstable"] impl> DoubleEndedIterator for Fuse { #[inline] fn next_back(&mut self) -> Option { @@ -1837,6 +1957,7 @@ impl> DoubleEndedIterator for Fuse { } // Allow RandomAccessIterators to be fused without affecting random-access behavior +#[experimental = "trait is experimental"] impl> RandomAccessIterator for Fuse { #[inline] fn indexable(&self) -> uint { @@ -1849,6 +1970,7 @@ impl> RandomAccessIterator for Fuse { } } +#[experimental = "seems marginal"] impl Fuse { /// 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 Fuse { /// 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> Iterator for Inspect<'a, A, T> { #[inline] fn next(&mut self) -> Option { @@ -1891,6 +2015,7 @@ impl<'a, A, T: Iterator> Iterator for Inspect<'a, A, T> { } } +#[unstable = "trait is unstable"] impl<'a, A, T: DoubleEndedIterator> DoubleEndedIterator for Inspect<'a, A, T> { #[inline] @@ -1900,6 +2025,7 @@ for Inspect<'a, A, T> { } } +#[experimental = "trait is experimental"] impl<'a, A, T: RandomAccessIterator> RandomAccessIterator 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, /// 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 for Unfold<'a, A, St> { #[inline] fn next(&mut self) -> Option { @@ -1950,6 +2079,7 @@ impl<'a, A, St> Iterator 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 { /// The current state the counter is at (next value to be yielded) state: A, @@ -1959,10 +2089,12 @@ pub struct Counter { /// Creates a new counter with the specified start/step #[inline] +#[unstable = "may be renamed"] pub fn count(start: A, step: A) -> Counter { Counter{state: start, step: step} } +#[unstable = "trait is unstable"] impl + Clone> Iterator for Counter { #[inline] fn next(&mut self) -> Option { @@ -1979,6 +2111,7 @@ impl + Clone> Iterator for Counter { /// An iterator over the range [start, stop) #[deriving(Clone)] +#[unstable = "may be refactored due to numerics reform or ops reform"] pub struct Range { state: A, stop: A, @@ -2008,6 +2141,7 @@ pub fn range(start: A, stop: A) -> Range { } // FIXME: #10414: Unfortunate type bound +#[unstable = "trait is unstable"] impl Iterator for Range { #[inline] fn next(&mut self) -> Option { @@ -2055,6 +2189,7 @@ impl Iterator for Range { /// `Int` is required to ensure the range will be the same regardless of /// the direction it is consumed. +#[unstable = "trait is unstable"] impl DoubleEndedIterator for Range { #[inline] fn next_back(&mut self) -> Option { @@ -2069,6 +2204,7 @@ impl DoubleEndedIterator for Range { /// An iterator over the range [start, stop] #[deriving(Clone)] +#[unstable = "may be refactored due to numerics reform or ops reform"] pub struct RangeInclusive { range: Range, done: bool, @@ -2076,6 +2212,7 @@ pub struct RangeInclusive { /// Return an iterator over the range [start, stop] #[inline] +#[unstable = "may be refactored due to numerics reform or ops reform"] pub fn range_inclusive(start: A, stop: A) -> RangeInclusive { RangeInclusive { range: range(start, stop), @@ -2083,6 +2220,7 @@ pub fn range_inclusive(start: A, stop: A) -> RangeInclusive { } } +#[unstable = "trait is unstable"] impl Iterator for RangeInclusive { #[inline] fn next(&mut self) -> Option { @@ -2115,6 +2253,7 @@ impl Iterator for RangeInclusive { } } +#[unstable = "trait is unstable"] impl DoubleEndedIterator for RangeInclusive { #[inline] fn next_back(&mut self) -> Option { @@ -2133,6 +2272,7 @@ impl DoubleEndedIterator for RangeInclusive { /// 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 { state: A, stop: A, @@ -2142,11 +2282,13 @@ pub struct RangeStep { /// 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(start: A, stop: A, step: A) -> RangeStep { let rev = step < Int::zero(); RangeStep{state: start, stop: stop, step: step, rev: rev} } +#[unstable = "trait is unstable"] impl Iterator for RangeStep { #[inline] fn next(&mut self) -> Option { @@ -2165,6 +2307,7 @@ impl Iterator for RangeStep { /// 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 { state: A, stop: A, @@ -2175,6 +2318,7 @@ pub struct RangeStepInclusive { /// 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(start: A, stop: A, step: A) -> RangeStepInclusive { let rev = step < Int::zero(); RangeStepInclusive { @@ -2186,6 +2330,7 @@ pub fn range_step_inclusive(start: A, stop: A, step: A) -> RangeStepIncl } } +#[unstable = "trait is unstable"] impl Iterator for RangeStepInclusive { #[inline] fn next(&mut self) -> Option { @@ -2205,6 +2350,7 @@ impl Iterator for RangeStepInclusive { /// An iterator that repeats an element endlessly #[deriving(Clone)] +#[stable] pub struct Repeat { element: A } @@ -2212,11 +2358,13 @@ pub struct Repeat { impl Repeat { /// Create a new `Repeat` that endlessly repeats the element `elt`. #[inline] + #[deprecated = "use iter::repeat instead"] pub fn new(elt: A) -> Repeat { Repeat{element: elt} } } +#[unstable = "trait is unstable"] impl Iterator for Repeat { #[inline] fn next(&mut self) -> Option { self.idx(0) } @@ -2224,11 +2372,13 @@ impl Iterator for Repeat { fn size_hint(&self) -> (uint, Option) { (uint::MAX, None) } } +#[unstable = "trait is unstable"] impl DoubleEndedIterator for Repeat { #[inline] fn next_back(&mut self) -> Option { self.idx(0) } } +#[experimental = "trait is experimental"] impl RandomAccessIterator for Repeat { #[inline] fn indexable(&self) -> uint { uint::MAX } @@ -2240,10 +2390,12 @@ type IterateState<'a, T> = (|T|: 'a -> T, Option, 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(elt: T) -> Repeat { - Repeat::new(elt) + Repeat{element: elt} } /// Functions for lexicographical ordering of sequences. @@ -2273,6 +2427,7 @@ pub fn repeat(elt: T) -> Repeat { /// /// 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}; From b299c2b57db90025cbf59d4b5152c9c37db6bc63 Mon Sep 17 00:00:00 2001 From: Aaron Turon Date: Thu, 6 Nov 2014 09:32:37 -0800 Subject: [PATCH 2/2] Fallout from stabilization --- src/libcollections/binary_heap.rs | 4 ++-- src/libcollections/bit.rs | 12 ++++++------ src/libcollections/btree/map.rs | 8 ++++---- src/libcollections/dlist.rs | 4 ++-- src/libcollections/ring_buf.rs | 7 +++---- src/libcollections/slice.rs | 2 +- src/libcollections/str.rs | 21 ++++++++++++--------- src/libcollections/vec.rs | 2 +- src/libcore/fmt/float.rs | 2 +- src/libcore/fmt/mod.rs | 2 +- src/libcore/fmt/num.rs | 2 +- src/libcore/num/mod.rs | 2 +- src/libcore/option.rs | 4 ++-- src/libcore/prelude.rs | 9 +++++---- src/libcore/result.rs | 4 ++-- src/libcore/slice.rs | 4 ++-- src/libcore/str.rs | 6 +++--- src/libgetopts/lib.rs | 2 +- src/librand/isaac.rs | 6 +++--- src/librustc/middle/cfg/construct.rs | 3 +-- src/librustc/middle/check_match.rs | 3 +-- src/librustc/middle/const_eval.rs | 2 +- src/librustc/middle/dependency_format.rs | 2 +- src/librustc/middle/entry.rs | 2 +- src/librustc/middle/pat_util.rs | 2 +- src/librustc/middle/ty.rs | 4 ++-- src/librustc/middle/typeck/check/mod.rs | 2 +- src/librustc_trans/save/recorder.rs | 2 +- src/librustc_trans/trans/base.rs | 2 +- src/librustdoc/clean/inline.rs | 2 +- src/librustdoc/html/format.rs | 2 +- src/librustdoc/html/markdown.rs | 4 ++-- src/librustrt/task.rs | 2 +- src/libstd/ascii.rs | 2 +- src/libstd/collections/hash/map.rs | 2 +- src/libstd/collections/hash/set.rs | 6 +++--- src/libstd/dynamic_lib.rs | 4 ++-- src/libstd/io/buffered.rs | 2 +- src/libstd/io/mod.rs | 2 +- src/libstd/io/net/addrinfo.rs | 2 +- src/libstd/io/net/ip.rs | 2 +- src/libstd/io/net/tcp.rs | 1 - src/libstd/io/stdio.rs | 1 - src/libstd/os.rs | 2 +- src/libstd/path/mod.rs | 2 +- src/libstd/path/posix.rs | 5 +++-- src/libstd/path/windows.rs | 3 ++- src/libstd/prelude.rs | 11 ++++++----- src/libstd/rand/mod.rs | 2 +- src/libstd/rt/backtrace.rs | 4 ++-- src/libstd/sys/windows/c.rs | 2 +- src/libstd/sys/windows/process.rs | 2 +- src/libsyntax/ast_map/mod.rs | 2 +- src/libsyntax/config.rs | 3 +-- src/libsyntax/ext/base.rs | 2 +- src/libsyntax/ext/format.rs | 2 +- src/libsyntax/owned_slice.rs | 2 +- src/libunicode/u_str.rs | 3 ++- 58 files changed, 105 insertions(+), 103 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 DoubleEndedIterator for MoveItems { fn next_back(&mut self) -> Option { self.iter.next_back() } } -impl ExactSize for MoveItems {} +impl ExactSizeIterator for MoveItems {} impl FromIterator for BinaryHeap { - fn from_iter>(mut iter: Iter) -> BinaryHeap { + fn from_iter>(iter: Iter) -> BinaryHeap { let vec: Vec = 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 for Bits<'a> { } } -impl<'a> ExactSize for Bits<'a> {} +impl<'a> ExactSizeIterator for Bits<'a> {} impl<'a> RandomAccessIterator 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 + DoubleEndedIterator>> // 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 Iterator<(K, V)> for MoveEntries { @@ -983,7 +983,7 @@ impl Iterator<(K, V)> for MoveEntries { impl DoubleEndedIterator<(K, V)> for MoveEntries { fn next_back(&mut self) -> Option<(K, V)> { self.inner.next_back() } } -impl ExactSize<(K, V)> for MoveEntries {} +impl ExactSizeIterator<(K, V)> for MoveEntries {} 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 { 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 PartialEq for RingBuf { fn eq(&self, other: &RingBuf) -> bool { @@ -1322,7 +1321,7 @@ mod tests { let u: Vec = 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 = 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 9982eaefff8..32059f7808f 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}; @@ -794,7 +794,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}; @@ -2143,12 +2143,15 @@ mod tests { let gr_inds = s.grapheme_indices(true).rev().collect::>(); 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 @@ -2285,7 +2288,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 a3291e01942..8b4428849d7 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -1319,7 +1319,7 @@ impl DoubleEndedIterator for MoveItems { } } -impl ExactSize for MoveItems {} +impl ExactSizeIterator for MoveItems {} #[unsafe_destructor] impl Drop for MoveItems { 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/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 DoubleEndedIterator for Item { } } -impl ExactSize for Item {} +impl ExactSizeIterator for Item {} ///////////////////////////////////////////////////////////////////////////// // 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 DoubleEndedIterator for Item { } } -impl ExactSize for Item {} +impl ExactSizeIterator for Item {} ///////////////////////////////////////////////////////////////////////////// // 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> for Matrix<'a> { - fn from_iter>>(mut iterator: T) -> Matrix<'a> { + fn from_iter>>(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>(mut cs: It) -> constness { +pub fn join_all>(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 { 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>>(cx: &ctxt<'tcx>, sp: Span, seen: &mut Vec>, - 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::>().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::>().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, S, H: Hasher> HashSet { /// ``` #[unstable = "matches collection reform specification, waiting for dust to settle"] pub fn difference<'a>(&'a self, other: &'a HashSet) -> 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, S, H: Hasher> HashSet { #[unstable = "matches collection reform specification, waiting for dust to settle"] pub fn intersection<'a>(&'a self, other: &'a HashSet) -> 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 cbac6b48b83..8ba91684d04 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 9b50361ec1f..3019e86575a 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 a185a29a700..078a9b1518f 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::{MaybeOwned, Str, StrPrelude}; diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs index 2b444fdc32b..027ac029288 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 9f81de72980..334227f42bb 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 65f45c3f97e..82691b111a8 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; @@ -64,10 +64,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 3fb5ee34356..4a6ae0b7e9e 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 for Values<'a, T> { /// The type of the iterator used by with_path. pub type PathElems<'a, 'b> = iter::Chain, LinkedPath<'b>>; -pub fn path_to_string>(mut path: PI) -> String { +pub fn path_to_string>(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], 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>>(mut it: I) -> Box { + pub fn new>>(it: I) -> Box { box MacItems { items: it.collect() } as Box } } 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 PartialEq for OwnedSlice { impl Eq for OwnedSlice {} impl FromIterator for OwnedSlice { - fn from_iter>(mut iter: I) -> OwnedSlice { + fn from_iter>(iter: I) -> OwnedSlice { 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};