Auto merge of rust-lang#22242 - Gankro:collect-ints, r=alexcrichton

Author: bors

src/libcollections/binary_heap.rs

@@ -255,7 +255,7 @@ impl<T: Ord> BinaryHeap<T> {
     ///
     /// // Print 1, 2, 3, 4 in arbitrary order
     /// for x in heap.into_iter() {
-    ///     // x has type int, not &int
+    ///     // x has type i32, not &i32
     ///     println!("{}", x);
     /// }
     /// ```

src/libcollections/btree/map.rs

@@ -1783,7 +1783,7 @@ mod test {
     fn test_entry(){
         let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)];
 
-        let mut map: BTreeMap<_, _> = xs.iter().map(|&x| x).collect();
+        let mut map: BTreeMap<_, _> = xs.iter().cloned().collect();
 
         // Existing key (insert)
         match map.entry(1) {

src/libcollections/btree/set.rs

@@ -89,7 +89,7 @@ impl<T: Ord> BTreeSet<T> {
     /// ```
     /// use std::collections::BTreeSet;
     ///
-    /// let mut set: BTreeSet<int> = BTreeSet::new();
+    /// let mut set: BTreeSet<i32> = BTreeSet::new();
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn new() -> BTreeSet<T> {
@@ -114,13 +114,13 @@ impl<T> BTreeSet<T> {
     /// ```
     /// use std::collections::BTreeSet;
     ///
-    /// let set: BTreeSet<usize> = [1, 2, 3, 4].iter().map(|&x| x).collect();
+    /// let set: BTreeSet<usize> = [1, 2, 3, 4].iter().cloned().collect();
     ///
     /// for x in set.iter() {
     ///     println!("{}", x);
     /// }
     ///
-    /// let v: Vec<usize> = set.iter().map(|&x| x).collect();
+    /// let v: Vec<usize> = set.iter().cloned().collect();
     /// assert_eq!(v, vec![1,2,3,4]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -135,7 +135,7 @@ impl<T> BTreeSet<T> {
     /// ```
     /// use std::collections::BTreeSet;
     ///
-    /// let set: BTreeSet<usize> = [1, 2, 3, 4].iter().map(|&x| x).collect();
+    /// let set: BTreeSet<usize> = [1, 2, 3, 4].iter().cloned().collect();
     ///
     /// let v: Vec<usize> = set.into_iter().collect();
     /// assert_eq!(v, vec![1,2,3,4]);
@@ -331,7 +331,7 @@ impl<T: Ord> BTreeSet<T> {
     /// ```
     /// use std::collections::BTreeSet;
     ///
-    /// let set: BTreeSet<int> = [1, 2, 3].iter().map(|&x| x).collect();
+    /// let set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
     /// assert_eq!(set.contains(&1), true);
     /// assert_eq!(set.contains(&4), false);
     /// ```
@@ -348,8 +348,8 @@ impl<T: Ord> BTreeSet<T> {
     /// ```
     /// use std::collections::BTreeSet;
     ///
-    /// let a: BTreeSet<int> = [1, 2, 3].iter().map(|&x| x).collect();
-    /// let mut b: BTreeSet<int> = BTreeSet::new();
+    /// let a: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
+    /// let mut b = BTreeSet::new();
     ///
     /// assert_eq!(a.is_disjoint(&b), true);
     /// b.insert(4);
@@ -369,8 +369,8 @@ impl<T: Ord> BTreeSet<T> {
     /// ```
     /// use std::collections::BTreeSet;
     ///
-    /// let sup: BTreeSet<int> = [1, 2, 3].iter().map(|&x| x).collect();
-    /// let mut set: BTreeSet<int> = BTreeSet::new();
+    /// let sup: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
+    /// let mut set = BTreeSet::new();
     ///
     /// assert_eq!(set.is_subset(&sup), true);
     /// set.insert(2);
@@ -411,8 +411,8 @@ impl<T: Ord> BTreeSet<T> {
     /// ```
     /// use std::collections::BTreeSet;
     ///
-    /// let sub: BTreeSet<int> = [1, 2].iter().map(|&x| x).collect();
-    /// let mut set: BTreeSet<int> = BTreeSet::new();
+    /// let sub: BTreeSet<_> = [1, 2].iter().cloned().collect();
+    /// let mut set = BTreeSet::new();
     ///
     /// assert_eq!(set.is_superset(&sub), false);
     ///
@@ -525,11 +525,11 @@ impl<'a, 'b, T: Ord + Clone> Sub<&'b BTreeSet<T>> for &'a BTreeSet<T> {
     /// ```
     /// use std::collections::BTreeSet;
     ///
-    /// let a: BTreeSet<int> = vec![1, 2, 3].into_iter().collect();
-    /// let b: BTreeSet<int> = vec![3, 4, 5].into_iter().collect();
+    /// let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect();
+    /// let b: BTreeSet<_> = vec![3, 4, 5].into_iter().collect();
     ///
-    /// let result: BTreeSet<int> = &a - &b;
-    /// let result_vec: Vec<int> = result.into_iter().collect();
+    /// let result = &a - &b;
+    /// let result_vec: Vec<_> = result.into_iter().collect();
     /// assert_eq!(result_vec, vec![1, 2]);
     /// ```
     fn sub(self, rhs: &BTreeSet<T>) -> BTreeSet<T> {
@@ -548,11 +548,11 @@ impl<'a, 'b, T: Ord + Clone> BitXor<&'b BTreeSet<T>> for &'a BTreeSet<T> {
     /// ```
     /// use std::collections::BTreeSet;
     ///
-    /// let a: BTreeSet<int> = vec![1, 2, 3].into_iter().collect();
-    /// let b: BTreeSet<int> = vec![2, 3, 4].into_iter().collect();
+    /// let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect();
+    /// let b: BTreeSet<_> = vec![2, 3, 4].into_iter().collect();
     ///
-    /// let result: BTreeSet<int> = &a ^ &b;
-    /// let result_vec: Vec<int> = result.into_iter().collect();
+    /// let result = &a ^ &b;
+    /// let result_vec: Vec<_> = result.into_iter().collect();
     /// assert_eq!(result_vec, vec![1, 4]);
     /// ```
     fn bitxor(self, rhs: &BTreeSet<T>) -> BTreeSet<T> {
@@ -571,11 +571,11 @@ impl<'a, 'b, T: Ord + Clone> BitAnd<&'b BTreeSet<T>> for &'a BTreeSet<T> {
     /// ```
     /// use std::collections::BTreeSet;
     ///
-    /// let a: BTreeSet<int> = vec![1, 2, 3].into_iter().collect();
-    /// let b: BTreeSet<int> = vec![2, 3, 4].into_iter().collect();
+    /// let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect();
+    /// let b: BTreeSet<_> = vec![2, 3, 4].into_iter().collect();
     ///
-    /// let result: BTreeSet<int> = &a & &b;
-    /// let result_vec: Vec<int> = result.into_iter().collect();
+    /// let result = &a & &b;
+    /// let result_vec: Vec<_> = result.into_iter().collect();
     /// assert_eq!(result_vec, vec![2, 3]);
     /// ```
     fn bitand(self, rhs: &BTreeSet<T>) -> BTreeSet<T> {
@@ -594,11 +594,11 @@ impl<'a, 'b, T: Ord + Clone> BitOr<&'b BTreeSet<T>> for &'a BTreeSet<T> {
     /// ```
     /// use std::collections::BTreeSet;
     ///
-    /// let a: BTreeSet<int> = vec![1, 2, 3].into_iter().collect();
-    /// let b: BTreeSet<int> = vec![3, 4, 5].into_iter().collect();
+    /// let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect();
+    /// let b: BTreeSet<_> = vec![3, 4, 5].into_iter().collect();
     ///
-    /// let result: BTreeSet<int> = &a | &b;
-    /// let result_vec: Vec<int> = result.into_iter().collect();
+    /// let result = &a | &b;
+    /// let result_vec: Vec<_> = result.into_iter().collect();
     /// assert_eq!(result_vec, vec![1, 2, 3, 4, 5]);
     /// ```
     fn bitor(self, rhs: &BTreeSet<T>) -> BTreeSet<T> {

src/libcollections/dlist.rs

@@ -756,7 +756,7 @@ impl<'a, A> IterMut<'a, A> {
     /// ```
     /// use std::collections::DList;
     ///
-    /// let mut list: DList<int> = vec![1, 3, 4].into_iter().collect();
+    /// let mut list: DList<_> = vec![1, 3, 4].into_iter().collect();
     ///
     /// {
     ///     let mut it = list.iter_mut();
@@ -765,7 +765,7 @@ impl<'a, A> IterMut<'a, A> {
     ///     it.insert_next(2);
     /// }
     /// {
-    ///     let vec: Vec<int> = list.into_iter().collect();
+    ///     let vec: Vec<_> = list.into_iter().collect();
     ///     assert_eq!(vec, vec![1, 2, 3, 4]);
     /// }
     /// ```
@@ -783,7 +783,7 @@ impl<'a, A> IterMut<'a, A> {
     /// ```
     /// use std::collections::DList;
     ///
-    /// let mut list: DList<int> = vec![1, 2, 3].into_iter().collect();
+    /// let mut list: DList<_> = vec![1, 2, 3].into_iter().collect();
     ///
     /// let mut it = list.iter_mut();
     /// assert_eq!(it.next().unwrap(), &1);

src/libcollections/fmt.rs

@@ -108,7 +108,7 @@
 //! There are various parameters which do require a particular type, however.
 //! Namely if the syntax `{:.*}` is used, then the number of characters to print
 //! precedes the actual object being formatted, and the number of characters
-//! must have the type `uint`. Although a `uint` can be printed with `{}`, it is
+//! must have the type `usize`. Although a `usize` can be printed with `{}`, it is
 //! illegal to reference an argument as such. For example this is another
 //! invalid format string:
 //!
@@ -121,7 +121,7 @@
 //! When requesting that an argument be formatted with a particular type, you
 //! are actually requesting that an argument ascribes to a particular trait.
 //! This allows multiple actual types to be formatted via `{:x}` (like `i8` as
-//! well as `int`).  The current mapping of types to traits is:
+//! well as `isize`).  The current mapping of types to traits is:
 //!
 //! * *nothing* ⇒ `Display`
 //! * `?` ⇒ `Debug`
@@ -173,8 +173,8 @@
 //!
 //! #[derive(Debug)]
 //! struct Vector2D {
-//!     x: int,
-//!     y: int,
+//!     x: isize,
+//!     y: isize,
 //! }
 //!
 //! impl fmt::Display for Vector2D {
@@ -380,9 +380,9 @@
 //! the '0' flag is specified for numerics, then the implicit fill character is
 //! '0'.
 //!
-//! The value for the width can also be provided as a `uint` in the list of
+//! The value for the width can also be provided as a `usize` in the list of
 //! parameters by using the `2$` syntax indicating that the second argument is a
-//! `uint` specifying the width.
+//! `usize` specifying the width.
 //!
 //! ### Precision
 //!

src/libcollections/slice.rs

@@ -73,7 +73,7 @@
 //!
 //! The method `iter()` returns an iteration value for a slice. The iterator
 //! yields references to the slice's elements, so if the element
-//! type of the slice is `int`, the element type of the iterator is `&int`.
+//! type of the slice is `isize`, the element type of the iterator is `&isize`.
 //!
 //! ```rust
 //! let numbers = [0, 1, 2];
@@ -1218,7 +1218,7 @@ impl Iterator for ElementSwaps {
         // Find the index of the largest mobile element:
         // The direction should point into the vector, and the
         // swap should be with a smaller `size` element.
-        let max = self.sdir.iter().map(|&x| x).enumerate()
+        let max = self.sdir.iter().cloned().enumerate()
                            .filter(|&(i, sd)|
                                 new_pos(i, sd.dir) < self.sdir.len() &&
                                 self.sdir[new_pos(i, sd.dir)].size < sd.size)

src/libcollections/str.rs

@@ -2705,22 +2705,22 @@ mod tests {
 
         for &(s, g) in &test_same[] {
             // test forward iterator
-            assert!(order::equals(s.graphemes(true), g.iter().map(|&x| x)));
-            assert!(order::equals(s.graphemes(false), g.iter().map(|&x| x)));
+            assert!(order::equals(s.graphemes(true), g.iter().cloned()));
+            assert!(order::equals(s.graphemes(false), g.iter().cloned()));
 
             // test reverse iterator
-            assert!(order::equals(s.graphemes(true).rev(), g.iter().rev().map(|&x| x)));
-            assert!(order::equals(s.graphemes(false).rev(), g.iter().rev().map(|&x| x)));
+            assert!(order::equals(s.graphemes(true).rev(), g.iter().rev().cloned()));
+            assert!(order::equals(s.graphemes(false).rev(), g.iter().rev().cloned()));
         }
 
         for &(s, gt, gf) in &test_diff {
             // test forward iterator
-            assert!(order::equals(s.graphemes(true), gt.iter().map(|&x| x)));
-            assert!(order::equals(s.graphemes(false), gf.iter().map(|&x| x)));
+            assert!(order::equals(s.graphemes(true), gt.iter().cloned()));
+            assert!(order::equals(s.graphemes(false), gf.iter().cloned()));
 
             // test reverse iterator
-            assert!(order::equals(s.graphemes(true).rev(), gt.iter().rev().map(|&x| x)));
-            assert!(order::equals(s.graphemes(false).rev(), gf.iter().rev().map(|&x| x)));
+            assert!(order::equals(s.graphemes(true).rev(), gt.iter().rev().cloned()));
+            assert!(order::equals(s.graphemes(false).rev(), gf.iter().rev().cloned()));
         }
 
         // test the indices iterators

src/libcollections/vec.rs

@@ -158,7 +158,7 @@ impl<T> Vec<T> {
     /// # Examples
     ///
     /// ```
-    /// let mut vec: Vec<int> = Vec::new();
+    /// let mut vec: Vec<i32> = Vec::new();
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -277,7 +277,7 @@ impl<T> Vec<T> {
     /// # Examples
     ///
     /// ```
-    /// let vec: Vec<int> = Vec::with_capacity(10);
+    /// let vec: Vec<i32> = Vec::with_capacity(10);
     /// assert_eq!(vec.capacity(), 10);
     /// ```
     #[inline]
@@ -296,7 +296,7 @@ impl<T> Vec<T> {
     /// # Examples
     ///
     /// ```
-    /// let mut vec: Vec<int> = vec![1];
+    /// let mut vec = vec![1];
     /// vec.reserve(10);
     /// assert!(vec.capacity() >= 11);
     /// ```
@@ -325,7 +325,7 @@ impl<T> Vec<T> {
     /// # Examples
     ///
     /// ```
-    /// let mut vec: Vec<int> = vec![1];
+    /// let mut vec = vec![1];
     /// vec.reserve_exact(10);
     /// assert!(vec.capacity() >= 11);
     /// ```
@@ -347,7 +347,7 @@ impl<T> Vec<T> {
     /// # Examples
     ///
     /// ```
-    /// let mut vec: Vec<int> = Vec::with_capacity(10);
+    /// let mut vec = Vec::with_capacity(10);
     /// vec.push_all(&[1, 2, 3]);
     /// assert_eq!(vec.capacity(), 10);
     /// vec.shrink_to_fit();
@@ -424,7 +424,7 @@ impl<T> Vec<T> {
     /// # Examples
     ///
     /// ```
-    /// fn foo(slice: &mut [int]) {}
+    /// fn foo(slice: &mut [i32]) {}
     ///
     /// let mut vec = vec![1, 2];
     /// foo(vec.as_mut_slice());
@@ -845,7 +845,7 @@ impl<T> Vec<T> {
             // This `as isize` cast is safe, because the size of the elements of the
             // vector is not 0, and:
             //
-            // 1) If the size of the elements in the vector is 1, the `int` may
+            // 1) If the size of the elements in the vector is 1, the `isize` may
             //    overflow, but it has the correct bit pattern so that the
             //    `.offset()` function will work.
             //
@@ -858,7 +858,7 @@ impl<T> Vec<T> {
             //        (0x1 + 0x8 = 0x1 - 0x8)
             //
             // 2) If the size of the elements in the vector is >1, the `usize` ->
-            //    `int` conversion can't overflow.
+            //    `isize` conversion can't overflow.
             let offset = vec.len() as isize;
             let start = vec.as_mut_ptr();
 
@@ -1528,7 +1528,7 @@ impl<T> AsSlice<T> for Vec<T> {
     /// # Examples
     ///
     /// ```
-    /// fn foo(slice: &[int]) {}
+    /// fn foo(slice: &[i32]) {}
     ///
     /// let vec = vec![1, 2];
     /// foo(vec.as_slice());
@@ -2172,7 +2172,7 @@ mod tests {
     fn test_zip_unzip() {
         let z1 = vec![(1, 4), (2, 5), (3, 6)];
 
-        let (left, right): (Vec<_>, Vec<_>) = z1.iter().map(|&x| x).unzip();
+        let (left, right): (Vec<_>, Vec<_>) = z1.iter().cloned().unzip();
 
         assert_eq!((1, 4), (left[0], right[0]));
         assert_eq!((2, 5), (left[1], right[1]));