refactor: resolve clippy lints

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

Author: mightyiam

.github/workflows/ci.yml

@@ -24,8 +24,8 @@ jobs:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
         with:
-          components: ${{ matrix.rust == 'stable' && 'clippy' || '' }}
-      - run: RUSTFLAGS="--deny warnings" cargo ${{ matrix.rust == 'stable' && 'clippy' || 'check' }} ${{ matrix.features }}
+          components: clippy
+      - run: RUSTFLAGS="--deny warnings" cargo clippy ${{ matrix.features }}
 
   msrv:
     runs-on: ubuntu-latest

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;
@@ -501,6 +503,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;
@@ -527,6 +531,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;
@@ -553,6 +559,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;
@@ -592,7 +600,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

@@ -138,6 +138,8 @@ where
 
 /// 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

@@ -46,15 +46,21 @@ mod specialization {
             let arr = [1; 1024];
 
             c.bench_function("internal specialized", move |b| {
-                b.iter(|| arr.iter().intersperse(&0).fold(0, |acc, x| acc + x))
+                b.iter(|| {
+                    #[allow(clippy::unnecessary_fold)]
+                    arr.iter().intersperse(&0).fold(0, |acc, x| acc + x)
+                })
             });
         }
 
         pub fn internal_unspecialized(c: &mut Criterion) {
             let arr = [1; 1024];
 
             c.bench_function("internal unspecialized", move |b| {
-                b.iter(|| Unspecialized(arr.iter().intersperse(&0)).fold(0, |acc, x| acc + x))
+                b.iter(|| {
+                    #[allow(clippy::unnecessary_fold)]
+                    Unspecialized(arr.iter().intersperse(&0)).fold(0, |acc, x| acc + x)
+                })
             });
         }
     }

examples/iris.rs

@@ -9,7 +9,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 {
@@ -38,7 +38,7 @@ impl FromStr for 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

@@ -607,11 +607,11 @@ where
             Some(item) => Ok(f(acc, item)),
             None => Err(acc),
         });
-        let res = match res {
+
+        match res {
             Ok(val) => val,
             Err(val) => val,
-        };
-        res
+        }
     }
 }
 

src/adaptors/multi_product.rs

@@ -220,9 +220,9 @@ where
         self.0.iter().fold(
             (0, Some(0)),
             |acc,
-             &MultiProductIter {
-                 ref iter,
-                 ref iter_orig,
+             MultiProductIter {
+                 iter,
+                 iter_orig,
                  cur: _,
              }| {
                 let cur_size = iter.size_hint();

src/either_or_both.rs

@@ -29,19 +29,13 @@ impl<A, B> EitherOrBoth<A, B> {
     /// If `Left`, return true. Otherwise, return false.
     /// Exclusive version of [`has_left`](EitherOrBoth::has_left).
     pub fn is_left(&self) -> bool {
-        match *self {
-            Left(_) => true,
-            _ => false,
-        }
+        matches!(*self, Left(_))
     }
 
     /// If `Right`, return true. Otherwise, return false.
     /// Exclusive version of [`has_right`](EitherOrBoth::has_right).
     pub fn is_right(&self) -> bool {
-        match *self {
-            Right(_) => true,
-            _ => false,
-        }
+        matches!(*self, Right(_))
     }
 
     /// If `Both`, return true. Otherwise, return false.
@@ -500,6 +494,7 @@ impl<T> EitherOrBoth<T, T> {
     }
 }
 
+#[allow(clippy::from_over_into)]
 impl<A, B> Into<Option<Either<A, B>>> for EitherOrBoth<A, B> {
     fn into(self) -> Option<Either<A, B>> {
         match self {

src/lib.rs

@@ -1008,7 +1008,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
@@ -2047,6 +2047,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,
@@ -4013,7 +4014,7 @@ where
             (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!(

src/tuple_impl.rs

@@ -62,7 +62,7 @@ where
             buffer
                 .iter()
                 .position(|x| x.is_none())
-                .unwrap_or_else(|| buffer.len())
+                .unwrap_or(buffer.len())
         };
         (len, Some(len))
     }

tests/quick.rs

@@ -779,11 +779,11 @@ quickcheck! {
 
     fn peek_nth_mut_replace(a: Vec<u16>, b: Vec<u16>) -> () {
         let mut it = peek_nth(a.iter());
-        for i in 0..a.len().min(b.len()) {
-            *it.peek_nth_mut(i).unwrap() = &b[i];
+        for (i, m) in b.iter().enumerate().take(a.len().min(b.len())) {
+            *it.peek_nth_mut(i).unwrap() = m;
         }
-        for i in 0..a.len() {
-            assert_eq!(it.next().unwrap(), b.get(i).unwrap_or(&a[i]));
+        for (i, m) in a.iter().enumerate() {
+             assert_eq!(it.next().unwrap(), b.get(i).unwrap_or(m));
         }
         assert_eq!(it.next(), None);
         assert_eq!(it.next(), None);
@@ -875,9 +875,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)
     }
@@ -999,7 +998,7 @@ quickcheck! {
                 }
             }
         }
-        cmb.next() == None
+        cmb.next().is_none()
     }
 }
 
@@ -1310,7 +1309,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))
     }
 }
 
@@ -1413,7 +1412,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

@@ -27,7 +27,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]