refactor: resolve clippy lints

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

Author: mightyiam

benches/bench1.rs

@@ -397,15 +397,14 @@ fn ziplongest(c: &mut Criterion) {
     c.bench_function("ziplongest", move |b| {
         b.iter(|| {
             let zip = v1.iter().zip_longest(v2.iter());
-            let sum = zip.fold(0u32, |mut acc, val| {
+            zip.fold(0u32, |mut acc, val| {
                 match val {
                     EitherOrBoth::Both(x, y) => acc += x * y,
                     EitherOrBoth::Left(x) => acc += x,
                     EitherOrBoth::Right(y) => acc += y,
                 }
                 acc
-            });
-            sum
+            })
         })
     });
 }
@@ -495,6 +494,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;
@@ -521,6 +522,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;
@@ -547,6 +550,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;
@@ -573,6 +578,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;
@@ -612,7 +619,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

@@ -1002,7 +1002,7 @@ where
     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

@@ -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

@@ -1009,7 +1009,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
@@ -2048,6 +2048,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,
@@ -4003,7 +4004,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

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

src/unique_impl.rs

@@ -61,7 +61,7 @@ where
     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);
@@ -115,7 +115,7 @@ where
     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

@@ -819,9 +819,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)
     }
@@ -943,7 +942,7 @@ quickcheck! {
                 }
             }
         }
-        cmb.next() == None
+        cmb.next().is_none()
     }
 }
 
@@ -1254,7 +1253,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))
     }
 }
 
@@ -1357,7 +1356,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]