diff --git a/src/libcollections/binary_heap.rs b/src/libcollections/binary_heap.rs index 8efc4cd50c1a6..ed9310284461c 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 64abc78daf309..903a9bd982324 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 adb9a9ae5bd3d..8a6d26c26bf3c 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 19216b32ce77f..3f95bda663e15 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 643b500ec3e2b..8f0b0d41b03d4 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 ab5ac5bf9e146..06e1ee0fc0f18 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 9982eaefff8f8..32059f7808f59 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 a3291e01942f1..8b4428849d722 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 1760c4d8e6616..31a46c26e2a73 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 6e77b0a7c7936..605148beb90b1 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 1c856a6e20870..a441ced03b26e 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 07f2e154c768e..ce61bd97e1323 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 fcf2dab690890..7d7b41bf7bfd8 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 9f883d6049623..6678a20087b72 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 3240b4207a1c5..202ac46449754 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 6625d19781a23..36464e4d29e46 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 bb7710c2acc12..b9586399aec5d 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 a182f582b5f34..74165dcabc4a0 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 02dd53e4214ba..517b50c49c7ef 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 61c56cf9ecc51..b42fb8ccc41f4 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 806fea3b54fd5..bcfc003480f43 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 98ac7e413ca7c..7b442fedc2477 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 e8e90e7498975..3cb628c2e65c5 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 fd0162b30d8ae..417e533624984 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 a51956797cad0..8d4fbfd4cbccc 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 98b958749d55e..2c8465e62d7c3 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 d38c5bc0ca9cf..754bdc8c8ea01 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 e245878dd8705..2102133f97d3d 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 bdf2eca21d6ec..6fe5298393e7d 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 16edccd154302..a646b7e1ccbee 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 43aef11ce5c2f..d523992b4c617 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 11dc8f4f66037..df25daa3ca1ac 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 63fa3938fc828..325bdc284acfc 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 9754e673d3849..403ca9d14321a 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 662ae913764f4..9c7967d17bb8f 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 2fbcb464358b3..f6d526cca395d 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 0f119d4448532..4b868f6a95b7c 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 148323762c8b8..025033a112c0c 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 681400e9db581..a25674030aeac 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 13f602de03a2c..d6a48fd39e623 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 d87768a086098..4812e911cc481 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 cbac6b48b8337..8ba91684d0438 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 d450e9f1dce3e..e6dd20f63fbbc 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 9b50361ec1f0d..3019e86575aac 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 a185a29a7006e..078a9b1518ffd 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 2b444fdc32bab..027ac02928856 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 9f81de72980ce..334227f42bbef 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 65f45c3f97e14..82691b111a80b 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 f9f9147b1071b..da690f5d154df 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 8102299438749..4f6c1f8a2c61a 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 b8e9b1dca3abc..e46765f25b8aa 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 3fb5ee34356fe..4a6ae0b7e9eb2 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 8a2202d28d5c7..6b97b931ef7c6 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 257bfd69f433d..4f718555d5331 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 1cbc2b98c93a8..8d0d399fa3153 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 b04a800a32d2a..490246f8246f5 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 f622e2d611276..b31b20c80c2ba 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 56b1f0907d5a4..03a50409d7e52 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};