Fixed warnings.

Author: orium

.travis.yml

@@ -2,7 +2,7 @@ language: rust
 sudo: false
 matrix:
   include:
-    - rust: 1.24.0
+    - rust: 1.27.0
     - rust: stable
     - rust: beta
     - rust: nightly

benches/bench1.rs

@@ -7,7 +7,6 @@ use test::{black_box};
 use itertools::Itertools;
 
 use itertools::free::cloned;
-use itertools::Permutations;
 
 use std::iter::repeat;
 use std::cmp;
@@ -621,31 +620,31 @@ fn fast_integer_sum<I>(iter: I) -> I::Item
 fn step_vec_2(b: &mut test::Bencher) {
     let v = vec![0; 1024];
     b.iter(|| {
-        fast_integer_sum(cloned(v.iter().step(2)))
+        fast_integer_sum(cloned(v.iter().step_by(2)))
     });
 }
 
 #[bench]
 fn step_vec_10(b: &mut test::Bencher) {
     let v = vec![0; 1024];
     b.iter(|| {
-        fast_integer_sum(cloned(v.iter().step(10)))
+        fast_integer_sum(cloned(v.iter().step_by(10)))
     });
 }
 
 #[bench]
 fn step_range_2(b: &mut test::Bencher) {
     let v = black_box(0..1024);
     b.iter(|| {
-        fast_integer_sum(v.clone().step(2))
+        fast_integer_sum(v.clone().step_by(2))
     });
 }
 
 #[bench]
 fn step_range_10(b: &mut test::Bencher) {
     let v = black_box(0..1024);
     b.iter(|| {
-        fast_integer_sum(v.clone().step(10))
+        fast_integer_sum(v.clone().step_by(10))
     });
 }
 

benches/fold_specialization.rs

@@ -36,7 +36,7 @@ mod specialization {
 
             b.iter(|| {
                 let mut sum = 0;
-                for &x in arr.into_iter().intersperse(&0) {
+                for &x in arr.iter().intersperse(&0) {
                     sum += x;
                 }
                 sum
@@ -49,7 +49,7 @@ mod specialization {
             let arr = [1; 1024];
 
             b.iter(|| {
-                arr.into_iter().intersperse(&0).fold(0, |acc, x| acc + x)
+                arr.iter().intersperse(&0).fold(0, |acc, x| acc + x)
             })
         }
 
@@ -59,7 +59,7 @@ mod specialization {
             let arr = [1; 1024];
 
             b.iter(|| {
-                Unspecialized(arr.into_iter().intersperse(&0)).fold(0, |acc, x| acc + x)
+                Unspecialized(arr.iter().intersperse(&0)).fold(0, |acc, x| acc + x)
             })
         }
     }

benches/tree_fold1.rs

@@ -17,7 +17,7 @@ trait IterEx : Iterator {
         let hint = self.size_hint().0;
         let cap = std::mem::size_of::<usize>() * 8 - hint.leading_zeros() as usize;
         let mut stack = Vec::with_capacity(cap);
-        self.enumerate().foreach(|(mut i, mut x)| {
+        self.enumerate().for_each(|(mut i, mut x)| {
             while (i & 1) != 0 {
                 x = f(stack.pop().unwrap(), x);
                 i >>= 1;

src/format.rs

@@ -30,7 +30,7 @@ pub struct Format<'a, I> {
 
 pub fn new_format<'a, I, F>(iter: I, separator: &'a str, f: F) -> FormatWith<'a, I, F>
     where I: Iterator,
-          F: FnMut(I::Item, &mut FnMut(&fmt::Display) -> fmt::Result) -> fmt::Result
+          F: FnMut(I::Item, &mut dyn FnMut(&dyn fmt::Display) -> fmt::Result) -> fmt::Result
 {
     FormatWith {
         sep: separator,
@@ -49,7 +49,7 @@ pub fn new_format_default<'a, I>(iter: I, separator: &'a str) -> Format<'a, I>
 
 impl<'a, I, F> fmt::Display for FormatWith<'a, I, F>
     where I: Iterator,
-          F: FnMut(I::Item, &mut FnMut(&fmt::Display) -> fmt::Result) -> fmt::Result
+          F: FnMut(I::Item, &mut dyn  FnMut(&dyn fmt::Display) -> fmt::Result) -> fmt::Result
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let (mut iter, mut format) = match self.inner.borrow_mut().take() {
@@ -58,13 +58,13 @@ impl<'a, I, F> fmt::Display for FormatWith<'a, I, F>
         };
 
         if let Some(fst) = iter.next() {
-            format(fst, &mut |disp: &fmt::Display| disp.fmt(f))?;
+            format(fst, &mut |disp: &dyn fmt::Display| disp.fmt(f))?;
             for elt in iter {
                 if self.sep.len() > 0 {
 
                     f.write_str(self.sep)?;
                 }
-                format(elt, &mut |disp: &fmt::Display| disp.fmt(f))?;
+                format(elt, &mut |disp: &dyn fmt::Display| disp.fmt(f))?;
             }
         }
         Ok(())

src/lib.rs

@@ -42,7 +42,7 @@
 //!
 //! ## Rust Version
 //!
-//! This version of itertools requires Rust 1.24 or later.
+//! This version of itertools requires Rust 1.27 or later.
 //!
 //! [`Iterator`]: https://doc.rust-lang.org/std/iter/trait.Iterator.html
 #![doc(html_root_url="https://docs.rs/itertools/0.8/")]
@@ -1692,7 +1692,7 @@ pub trait Itertools : Iterator {
     /// ```
     fn format_with<F>(self, sep: &str, format: F) -> FormatWith<Self, F>
         where Self: Sized,
-              F: FnMut(Self::Item, &mut FnMut(&fmt::Display) -> fmt::Result) -> fmt::Result,
+              F: FnMut(Self::Item, &mut dyn FnMut(&dyn fmt::Display) -> fmt::Result) -> fmt::Result,
     {
         format::new_format(self, sep, format)
     }

tests/quick.rs

@@ -86,7 +86,7 @@ impl qc::Arbitrary for Inexact {
         }
     }
 
-    fn shrink(&self) -> Box<Iterator<Item=Self>> {
+    fn shrink(&self) -> Box<dyn Iterator<Item=Self>> {
         let underestimate_value = self.underestimate;
         let overestimate_value = self.overestimate;
         Box::new(
@@ -177,7 +177,7 @@ impl<T, HK> qc::Arbitrary for Iter<T, HK>
         Iter::new(T::arbitrary(g)..T::arbitrary(g), HK::arbitrary(g))
     }
 
-    fn shrink(&self) -> Box<Iterator<Item=Iter<T, HK>>>
+    fn shrink(&self) -> Box<dyn Iterator<Item=Iter<T, HK>>>
     {
         let r = self.iterator.clone();
         let hint_kind = self.hint_kind;
@@ -1076,7 +1076,7 @@ impl qc::Arbitrary for Val {
         let (x, y) = <(u32, u32)>::arbitrary(g);
         Val(x, y)
     }
-    fn shrink(&self) -> Box<Iterator<Item = Self>> {
+    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
         Box::new((self.0, self.1).shrink().map(|(x, y)| Val(x, y)))
     }
 }

tests/test_std.rs

@@ -198,12 +198,12 @@ fn trait_pointers() {
         }
     }
 
-    let mut it = Box::new(0..10) as Box<Iterator<Item=i32>>;
+    let mut it = Box::new(0..10) as Box<dyn Iterator<Item=i32>>;
     assert_eq!(it.next(), Some(0));
 
     {
         /* make sure foreach works on non-Sized */
-        let jt: &mut Iterator<Item = i32> = &mut *it;
+        let jt: &mut dyn Iterator<Item = i32> = &mut *it;
         assert_eq!(jt.next(), Some(1));
 
         {