build: resolve clippy problems

Co-authored-by: warren2k <[email protected]>

Author: mightyiam

benches/bench1.rs

@@ -475,6 +475,8 @@ fn merge_default(c: &mut Criterion) {
     let mut data1 = vec![0; 1024];
     let mut data2 = vec![0; 800];
     let mut x = 0;
+
+    #[allow(clippy::explicit_counter_loop)]
     for (_, elt) in data1.iter_mut().enumerate() {
         *elt = x;
         x += 1;
@@ -503,6 +505,8 @@ fn merge_by_cmp(c: &mut Criterion) {
     let mut data1 = vec![0; 1024];
     let mut data2 = vec![0; 800];
     let mut x = 0;
+
+    #[allow(clippy::explicit_counter_loop)]
     for (_, elt) in data1.iter_mut().enumerate() {
         *elt = x;
         x += 1;
@@ -531,6 +535,8 @@ fn merge_by_lt(c: &mut Criterion) {
     let mut data1 = vec![0; 1024];
     let mut data2 = vec![0; 800];
     let mut x = 0;
+
+    #[allow(clippy::explicit_counter_loop)]
     for (_, elt) in data1.iter_mut().enumerate() {
         *elt = x;
         x += 1;
@@ -559,6 +565,8 @@ fn kmerge_default(c: &mut Criterion) {
     let mut data1 = vec![0; 1024];
     let mut data2 = vec![0; 800];
     let mut x = 0;
+
+    #[allow(clippy::explicit_counter_loop)]
     for (_, elt) in data1.iter_mut().enumerate() {
         *elt = x;
         x += 1;
@@ -600,7 +608,7 @@ fn kmerge_tenway(c: &mut Criterion) {
 
     let mut chunks = Vec::new();
     let mut rest = &mut data[..];
-    while rest.len() > 0 {
+    while !rest.is_empty() {
         let chunk_len = 1 + rng(&mut state) % 512;
         let chunk_len = cmp::min(rest.len(), chunk_len as usize);
         let (fst, tail) = {rest}.split_at_mut(chunk_len);

benches/extra/zipslices.rs

@@ -137,6 +137,8 @@ unsafe impl<T, U> Slice for ZipSlices<T, U>
 
 /// A helper trait to let `ZipSlices` accept both `&[T]` and `&mut [T]`.
 ///
+/// # Safety
+///
 /// Unsafe trait because:
 ///
 /// - Implementors must guarantee that `get_unchecked` is valid for all indices `0..len()`.

benches/fold_specialization.rs

@@ -50,6 +50,7 @@ mod specialization {
 
             c.bench_function("internal specialized", move |b| {
                 b.iter(|| {
+                    #[allow(clippy::unnecessary_fold)]
                     arr.iter().intersperse_wrap(&0).fold(0, |acc, x| acc + x)
                 })
             });
@@ -61,6 +62,7 @@ mod specialization {
 
             c.bench_function("internal unspecialized", move |b| {
                 b.iter(|| {
+                    #[allow(clippy::unnecessary_fold)]
                     Unspecialized(arr.iter().intersperse_wrap(&0)).fold(0, |acc, x| acc + x)
                 })
             });

examples/iris.rs

@@ -10,7 +10,7 @@ use std::iter::repeat;
 use std::num::ParseFloatError;
 use std::str::FromStr;
 
-static DATA: &'static str = include_str!("iris.data");
+static DATA: &str = include_str!("iris.data");
 
 #[derive(Clone, Debug)]
 struct Iris {
@@ -36,7 +36,7 @@ impl FromStr for Iris {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let mut iris = Iris { name: "".into(), data: [0.; 4] };
-        let mut parts = s.split(",").map(str::trim);
+        let mut parts = s.split(',').map(str::trim);
 
         // using Iterator::by_ref()
         for (index, part) in parts.by_ref().take(4).enumerate() {

src/adaptors/mod.rs

@@ -891,7 +891,7 @@ impl<I, F> Iterator for Positions<I, F>
     type Item = usize;
 
     fn next(&mut self) -> Option<Self::Item> {
-        while let Some(v) = self.iter.next() {
+        for v in self.iter.by_ref() {
             let i = self.count;
             self.count = i + 1;
             if (self.f)(v) {

src/adaptors/multi_product.rs

@@ -205,7 +205,7 @@ impl<I> Iterator for MultiProduct<I>
 
         self.0.iter().fold(
             (0, Some(0)),
-            |acc, &MultiProductIter { ref iter, ref iter_orig, cur: _ }| {
+            |acc, MultiProductIter { iter, iter_orig, cur: _ }| {
                 let cur_size = iter.size_hint();
                 let total_size = iter_orig.size_hint();
                 size_hint::add(size_hint::mul(acc, total_size), cur_size)

src/lib.rs

@@ -1006,7 +1006,7 @@ pub trait Itertools : Iterator {
               J: IntoIterator<Item = Self::Item>,
               F: FnMut(&Self::Item, &Self::Item) -> bool
     {
-        merge_join::merge_by_new(self, other.into_iter(), is_first)
+        merge_join::merge_by_new(self, other, is_first)
     }
 
     /// Create an iterator that merges items from both this and the specified
@@ -2011,6 +2011,7 @@ pub trait Itertools : Iterator {
     /// let data : Option<usize> = None;
     /// assert_eq!(data.into_iter().all_equal_value(), Err(None));
     /// ```
+    #[allow(clippy::type_complexity)]
     fn all_equal_value(&mut self) -> Result<Self::Item, Option<(Self::Item, Self::Item)>>
         where
             Self: Sized,
@@ -3908,7 +3909,7 @@ pub fn assert_equal<I, J>(a: I, b: J)
             (None, None) => return,
             (a, b) => {
                 let equal = match (&a, &b) {
-                    (&Some(ref a), &Some(ref b)) => a == b,
+                    (Some(a), Some(b)) => a == b,
                     _ => false,
                 };
                 assert!(equal, "Failed assertion {a:?} == {b:?} for iteration {i}",

src/tuple_impl.rs

@@ -63,7 +63,7 @@ impl<T> Iterator for TupleBuffer<T>
         } else {
             buffer.iter()
                   .position(|x| x.is_none())
-                  .unwrap_or_else(|| buffer.len())
+                  .unwrap_or(buffer.len())
         };
         (len, Some(len))
     }

src/unique_impl.rs

@@ -57,7 +57,7 @@ impl<I, V, F> Iterator for UniqueBy<I, V, F>
     type Item = I::Item;
 
     fn next(&mut self) -> Option<Self::Item> {
-        while let Some(v) = self.iter.next() {
+        for v in self.iter.by_ref() {
             let key = (self.f)(&v);
             if self.used.insert(key, ()).is_none() {
                 return Some(v);
@@ -107,7 +107,7 @@ impl<I> Iterator for Unique<I>
     type Item = I::Item;
 
     fn next(&mut self) -> Option<Self::Item> {
-        while let Some(v) = self.iter.iter.next() {
+        for v in self.iter.iter.by_ref() {
             if let Entry::Vacant(entry) = self.iter.used.entry(v) {
                 let elt = entry.key().clone();
                 entry.insert(());

tests/quick.rs

@@ -817,9 +817,8 @@ quickcheck! {
 quickcheck! {
     fn size_put_back(a: Vec<u8>, x: Option<u8>) -> bool {
         let mut it = put_back(a.into_iter());
-        match x {
-            Some(t) => it.put_back(t),
-            None => {}
+        if let Some(t) = x {
+            it.put_back(t)
         }
         correct_size_hint(it)
     }
@@ -918,7 +917,7 @@ quickcheck! {
                 }
             }
         }
-        cmb.next() == None
+        cmb.next().is_none()
     }
 }
 
@@ -1205,7 +1204,7 @@ struct Val(u32, u32);
 
 impl PartialOrd<Val> for Val {
     fn partial_cmp(&self, other: &Val) -> Option<Ordering> {
-        self.0.partial_cmp(&other.0)
+        Some(self.cmp(other))
     }
 }
 
@@ -1308,7 +1307,7 @@ quickcheck! {
     fn at_most_one_i32(a: Vec<i32>) -> TestResult {
         let ret = a.iter().cloned().at_most_one();
         match a.len() {
-            0 => TestResult::from_bool(ret.unwrap() == None),
+            0 => TestResult::from_bool(ret.unwrap().is_none()),
             1 => TestResult::from_bool(ret.unwrap() == Some(a[0])),
             _ => TestResult::from_bool(ret.unwrap_err().eq(a.iter().cloned())),
         }

tests/test_core.rs

@@ -30,7 +30,7 @@ fn product2() {
     assert!(prod.next() == Some(('α', 1)));
     assert!(prod.next() == Some(('β', 0)));
     assert!(prod.next() == Some(('β', 1)));
-    assert!(prod.next() == None);
+    assert!(prod.next().is_none());
 }
 
 #[test]