diff --git a/src/libcollections/binary_heap.rs b/src/libcollections/binary_heap.rs index ba317334cfa0b..2988a6360955f 100644 --- a/src/libcollections/binary_heap.rs +++ b/src/libcollections/binary_heap.rs @@ -980,13 +980,13 @@ impl<'a, T> IntoIterator for &'a BinaryHeap where T: Ord { #[stable(feature = "rust1", since = "1.0.0")] impl Extend for BinaryHeap { - fn extend>(&mut self, iterable: I) { - let iter = iterable.into_iter(); - let (lower, _) = iter.size_hint(); + fn extend>(&mut self, iter: I) { + let iterator = iter.into_iter(); + let (lower, _) = iterator.size_hint(); self.reserve(lower); - for elem in iter { + for elem in iterator { self.push(elem); } } diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index d2432a4b03226..6731b15fb2e9c 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -1388,35 +1388,35 @@ impl Clone for String { #[stable(feature = "rust1", since = "1.0.0")] impl FromIterator for String { - fn from_iter>(iterable: I) -> String { + fn from_iter>(iter: I) -> String { let mut buf = String::new(); - buf.extend(iterable); + buf.extend(iter); buf } } #[stable(feature = "rust1", since = "1.0.0")] impl<'a> FromIterator<&'a str> for String { - fn from_iter>(iterable: I) -> String { + fn from_iter>(iter: I) -> String { let mut buf = String::new(); - buf.extend(iterable); + buf.extend(iter); buf } } #[stable(feature = "extend_string", since = "1.4.0")] impl FromIterator for String { - fn from_iter>(iterable: I) -> String { + fn from_iter>(iter: I) -> String { let mut buf = String::new(); - buf.extend(iterable); + buf.extend(iter); buf } } #[stable(feature = "rust1", since = "1.0.0")] impl Extend for String { - fn extend>(&mut self, iterable: I) { - let iterator = iterable.into_iter(); + fn extend>(&mut self, iter: I) { + let iterator = iter.into_iter(); let (lower_bound, _) = iterator.size_hint(); self.reserve(lower_bound); for ch in iterator { @@ -1427,15 +1427,15 @@ impl Extend for String { #[stable(feature = "extend_ref", since = "1.2.0")] impl<'a> Extend<&'a char> for String { - fn extend>(&mut self, iterable: I) { - self.extend(iterable.into_iter().cloned()); + fn extend>(&mut self, iter: I) { + self.extend(iter.into_iter().cloned()); } } #[stable(feature = "rust1", since = "1.0.0")] impl<'a> Extend<&'a str> for String { - fn extend>(&mut self, iterable: I) { - for s in iterable { + fn extend>(&mut self, iter: I) { + for s in iter { self.push_str(s) } } @@ -1443,8 +1443,8 @@ impl<'a> Extend<&'a str> for String { #[stable(feature = "extend_string", since = "1.4.0")] impl Extend for String { - fn extend>(&mut self, iterable: I) { - for s in iterable { + fn extend>(&mut self, iter: I) { + for s in iter { self.push_str(&s) } } diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 4f4eae67e37cd..dde5cbb508e1b 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -1302,13 +1302,13 @@ impl ops::DerefMut for Vec { #[stable(feature = "rust1", since = "1.0.0")] impl FromIterator for Vec { #[inline] - fn from_iter>(iterable: I) -> Vec { + fn from_iter>(iter: I) -> Vec { // Unroll the first iteration, as the vector is going to be // expanded on this iteration in every case when the iterable is not // empty, but the loop in extend_desugared() is not going to see the // vector being full in the few subsequent loop iterations. // So we get better branch prediction. - let mut iterator = iterable.into_iter(); + let mut iterator = iter.into_iter(); let mut vector = match iterator.next() { None => return Vec::new(), Some(element) => { @@ -1389,8 +1389,8 @@ impl<'a, T> IntoIterator for &'a mut Vec { #[stable(feature = "rust1", since = "1.0.0")] impl Extend for Vec { #[inline] - fn extend>(&mut self, iterable: I) { - self.extend_desugared(iterable.into_iter()) + fn extend>(&mut self, iter: I) { + self.extend_desugared(iter.into_iter()) } } diff --git a/src/libcollections/vec_deque.rs b/src/libcollections/vec_deque.rs index 3e48f14d387ff..9e2b25d178fb9 100644 --- a/src/libcollections/vec_deque.rs +++ b/src/libcollections/vec_deque.rs @@ -2057,8 +2057,8 @@ impl IndexMut for VecDeque { #[stable(feature = "rust1", since = "1.0.0")] impl FromIterator for VecDeque { - fn from_iter>(iterable: T) -> VecDeque { - let iterator = iterable.into_iter(); + fn from_iter>(iter: T) -> VecDeque { + let iterator = iter.into_iter(); let (lower, _) = iterator.size_hint(); let mut deq = VecDeque::with_capacity(lower); deq.extend(iterator); diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index 4dbcf7ab4e320..b4378a5fec58d 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -2458,10 +2458,10 @@ impl<'a, I: Iterator + ?Sized> Iterator for &'a mut I { /// /// // and we'll implement FromIterator /// impl FromIterator for MyCollection { -/// fn from_iter>(iterator: I) -> Self { +/// fn from_iter>(iter: I) -> Self { /// let mut c = MyCollection::new(); /// -/// for i in iterator { +/// for i in iter { /// c.add(i); /// } /// @@ -2508,7 +2508,7 @@ pub trait FromIterator: Sized { /// assert_eq!(v, vec![5, 5, 5, 5, 5]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - fn from_iter>(iterator: T) -> Self; + fn from_iter>(iter: T) -> Self; } /// Conversion into an `Iterator`. @@ -2683,11 +2683,11 @@ impl IntoIterator for I { /// // This is a bit simpler with the concrete type signature: we can call /// // extend on anything which can be turned into an Iterator which gives /// // us i32s. Because we need i32s to put into MyCollection. -/// fn extend>(&mut self, iterable: T) { +/// fn extend>(&mut self, iter: T) { /// /// // The implementation is very straightforward: loop through the /// // iterator, and add() each element to ourselves. -/// for elem in iterable { +/// for elem in iter { /// self.add(elem); /// } /// } @@ -2727,7 +2727,7 @@ pub trait Extend { /// assert_eq!("abcdef", &message); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - fn extend>(&mut self, iterable: T); + fn extend>(&mut self, iter: T); } /// An iterator able to yield elements from both ends. diff --git a/src/librustc_unicode/char.rs b/src/librustc_unicode/char.rs index 7b9296bb4c893..4d8021138a0d5 100644 --- a/src/librustc_unicode/char.rs +++ b/src/librustc_unicode/char.rs @@ -748,7 +748,7 @@ pub struct DecodeUtf16 buf: Option, } -/// Create an iterator over the UTF-16 encoded code points in `iterable`, +/// Create an iterator over the UTF-16 encoded code points in `iter`, /// returning unpaired surrogates as `Err`s. /// /// # Examples @@ -796,9 +796,9 @@ pub struct DecodeUtf16 /// ``` #[unstable(feature = "decode_utf16", reason = "recently exposed", issue = "27830")] #[inline] -pub fn decode_utf16>(iterable: I) -> DecodeUtf16 { +pub fn decode_utf16>(iter: I) -> DecodeUtf16 { DecodeUtf16 { - iter: iterable.into_iter(), + iter: iter.into_iter(), buf: None, } } diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs index ed797a7ee08ff..7ab5c90b0abde 100644 --- a/src/libstd/collections/hash/map.rs +++ b/src/libstd/collections/hash/map.rs @@ -1580,11 +1580,11 @@ impl<'a, K: 'a, V: 'a> VacantEntry<'a, K, V> { impl FromIterator<(K, V)> for HashMap where K: Eq + Hash, S: BuildHasher + Default { - fn from_iter>(iterable: T) -> HashMap { - let iter = iterable.into_iter(); - let lower = iter.size_hint().0; + fn from_iter>(iter: T) -> HashMap { + let iterator = iter.into_iter(); + let lower = iterator.size_hint().0; let mut map = HashMap::with_capacity_and_hasher(lower, Default::default()); - map.extend(iter); + map.extend(iterator); map } } diff --git a/src/libstd/collections/hash/set.rs b/src/libstd/collections/hash/set.rs index 8415395579725..fdde1773a4518 100644 --- a/src/libstd/collections/hash/set.rs +++ b/src/libstd/collections/hash/set.rs @@ -633,11 +633,11 @@ impl FromIterator for HashSet where T: Eq + Hash, S: BuildHasher + Default, { - fn from_iter>(iterable: I) -> HashSet { - let iter = iterable.into_iter(); - let lower = iter.size_hint().0; + fn from_iter>(iter: I) -> HashSet { + let iterator = iter.into_iter(); + let lower = iterator.size_hint().0; let mut set = HashSet::with_capacity_and_hasher(lower, Default::default()); - set.extend(iter); + set.extend(iterator); set } } diff --git a/src/libstd/sys/common/wtf8.rs b/src/libstd/sys/common/wtf8.rs index 8b79016c2516e..f64f835e19854 100644 --- a/src/libstd/sys/common/wtf8.rs +++ b/src/libstd/sys/common/wtf8.rs @@ -356,8 +356,8 @@ impl FromIterator for Wtf8Buf { /// This replaces surrogate code point pairs with supplementary code points, /// like concatenating ill-formed UTF-16 strings effectively would. impl Extend for Wtf8Buf { - fn extend>(&mut self, iterable: T) { - let iterator = iterable.into_iter(); + fn extend>(&mut self, iter: T) { + let iterator = iter.into_iter(); let (low, _high) = iterator.size_hint(); // Lower bound of one byte per code point (ASCII only) self.bytes.reserve(low);