fix clippy::type_repetition_in_bounds

Author: hellow554

src/adaptors/coalesce.rs

@@ -13,9 +13,11 @@ where
     f: F,
 }
 
-impl<I: Clone, F: Clone, T: Clone> Clone for CoalesceBy<I, F, T>
+impl<I, F, T> Clone for CoalesceBy<I, F, T>
 where
-    I: Iterator,
+    I: Clone + Iterator,
+    F: Clone,
+    T: Clone,
 {
     clone_fields!(last, iter, f);
 }

src/free.rs

@@ -151,9 +151,9 @@ pub fn chain<I, J>(i: I, j: J) -> iter::Chain<<I as IntoIterator>::IntoIter, <J
 ///
 /// assert_eq!(cloned(b"abc").next(), Some(b'a'));
 /// ```
-pub fn cloned<'a, I, T: 'a>(iterable: I) -> iter::Cloned<I::IntoIter>
+pub fn cloned<'a, I, T>(iterable: I) -> iter::Cloned<I::IntoIter>
     where I: IntoIterator<Item=&'a T>,
-          T: Clone,
+          T: Clone + 'a,
 {
     iterable.into_iter().cloned()
 }

src/groupbylazy.rs

@@ -7,8 +7,8 @@ trait KeyFunction<A> {
     fn call_mut(&mut self, arg: A) -> Self::Key;
 }
 
-impl<A, K, F: ?Sized> KeyFunction<A> for F
-    where F: FnMut(A) -> K
+impl<A, K, F> KeyFunction<A> for F
+    where F: FnMut(A) -> K + ?Sized
 {
     type Key = K;
     #[inline]
@@ -356,9 +356,12 @@ impl<'a, K, I, F> IntoIterator for &'a GroupBy<K, I, F>
 ///
 /// See [`.group_by()`](crate::Itertools::group_by) for more information.
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
-pub struct Groups<'a, K: 'a, I: 'a, F: 'a>
-    where I: Iterator,
-          I::Item: 'a
+pub struct Groups<'a, K, I, F>
+    where I: Iterator + 'a,
+          I::Item: 'a,
+          K: 'a,
+          F: 'a,
+
 {
     parent: &'a GroupBy<K, I, F>,
 }
@@ -390,9 +393,11 @@ impl<'a, K, I, F> Iterator for Groups<'a, K, I, F>
 /// An iterator for the elements in a single group.
 ///
 /// Iterator element type is `I::Item`.
-pub struct Group<'a, K: 'a, I: 'a, F: 'a>
-    where I: Iterator,
+pub struct Group<'a, K, I, F>
+    where I: Iterator + 'a,
           I::Item: 'a,
+          K: 'a,
+          F: 'a,
 {
     parent: &'a GroupBy<K, I, F>,
     index: usize,
@@ -507,8 +512,8 @@ impl<'a, I> IntoIterator for &'a IntoChunks<I>
 ///
 /// See [`.chunks()`](crate::Itertools::chunks) for more information.
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
-pub struct Chunks<'a, I: 'a>
-    where I: Iterator,
+pub struct Chunks<'a, I>
+    where I: Iterator + 'a,
           I::Item: 'a,
 {
     parent: &'a IntoChunks<I>,
@@ -538,8 +543,8 @@ impl<'a, I> Iterator for Chunks<'a, I>
 /// An iterator for the elements in a single chunk.
 ///
 /// Iterator element type is `I::Item`.
-pub struct Chunk<'a, I: 'a>
-    where I: Iterator,
+pub struct Chunk<'a, I>
+    where I: Iterator + 'a,
           I::Item: 'a,
 {
     parent: &'a IntoChunks<I>,

src/lib.rs

@@ -1917,8 +1917,7 @@ pub trait Itertools : Iterator {
     /// itertools::assert_equal(init, vec![0, 3, 6]);
     /// ```
     fn dropping_back(mut self, n: usize) -> Self
-        where Self: Sized,
-              Self: DoubleEndedIterator
+        where Self: Sized + DoubleEndedIterator,
     {
         if n > 0 {
             (&mut self).rev().nth(n - 1);
@@ -3654,7 +3653,7 @@ pub trait Itertools : Iterator {
     }
 }
 
-impl<T: ?Sized> Itertools for T where T: Iterator { }
+impl<T> Itertools for T where T: Iterator + ?Sized { }
 
 /// Return `true` if both iterables produce equal sequences
 /// (elements pairwise equal and sequences of the same length),

src/peeking_take_while.rs

@@ -76,16 +76,16 @@ impl<I> PeekingNext for PutBackN<I>
 /// See [`.peeking_take_while()`](crate::Itertools::peeking_take_while)
 /// for more information.
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
-pub struct PeekingTakeWhile<'a, I: 'a, F>
-    where I: Iterator,
+pub struct PeekingTakeWhile<'a, I, F>
+    where I: Iterator + 'a,
 {
     iter: &'a mut I,
     f: F,
 }
 
-impl<'a, I: 'a, F> std::fmt::Debug for PeekingTakeWhile<'a, I, F>
+impl<'a, I, F> std::fmt::Debug for PeekingTakeWhile<'a, I, F>
 where
-    I: Iterator + std::fmt::Debug,
+    I: Iterator + std::fmt::Debug + 'a,
 {
     debug_fmt_fields!(PeekingTakeWhile, iter);
 }

src/tuple_impl.rs

@@ -203,7 +203,7 @@ impl<I, T> FusedIterator for TupleWindows<I, T>
 /// information.
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 #[derive(Debug)]
-pub struct CircularTupleWindows<I, T: Clone>
+pub struct CircularTupleWindows<I, T>
     where I: Iterator<Item = T::Item> + Clone,
           T: TupleCollect + Clone
 {

src/ziptuple.rs

@@ -38,8 +38,7 @@ pub struct Zip<T> {
 /// ```
 /// [`izip!()`]: crate::izip
 pub fn multizip<T, U>(t: U) -> Zip<T>
-    where Zip<T>: From<U>,
-          Zip<T>: Iterator,
+    where Zip<T>: From<U> + Iterator,
 {
     Zip::from(t)
 }