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/combinations.rs

@@ -211,8 +211,11 @@ fn remaining_for(n: usize, first: bool, indices: &[usize]) -> Option<usize> {
             // TODO: Once the MSRV hits 1.37.0, we can sum options instead:
             // .map(|(i, n0)| checked_binomial(n - 1 - *n0, k - i))
             // .sum()
-            .fold(Some(0), |sum, (i, n0)| {
-                sum.and_then(|s| s.checked_add(checked_binomial(n - 1 - *n0, k - i)?))
+            // .fold(Some(0), |sum, (i, n0)| {
+            //     sum.and_then(|s| s.checked_add(checked_binomial(n - 1 - *n0, k - i)?))
+            // })
+            .try_fold(0usize, |sum, (i, n0)| {
+                sum.checked_add(checked_binomial(n - 1 - *n0, k - i)?)
             })
     }
 }

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/permutations.rs

@@ -247,8 +247,8 @@ impl CompleteState {
                     return Known(0);
                 }
 
-                let count: Option<usize> = (n - k + 1..n + 1).fold(Some(1), |acc, i| {
-                    acc.and_then(|acc| acc.checked_mul(i))
+                let count: Option<usize> = (n - k + 1..n + 1).try_fold(1usize, |acc, i| {
+                    acc.checked_mul(i)
                 });
 
                 match count {

src/powerset.rs

@@ -82,7 +82,7 @@ impl<I> FusedIterator for Powerset<I>
 {}
 
 fn remaining_for(n: usize, k: usize) -> Option<usize> {
-    (k + 1..=n).fold(Some(0), |sum, i| {
-        sum.and_then(|s| s.checked_add(checked_binomial(n, i)?))
+    (k + 1..=n).try_fold(0usize, |sum, i| {
+        sum.checked_add(checked_binomial(n, 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())),
         }
@@ -1338,7 +1337,7 @@ quickcheck! {
                     Some(acc.unwrap_or(0) + val)
                 }
             });
-        
+
         let group_map_lookup = a.iter()
             .map(|&b| b as u64)
             .map(|i| (i % modulo, i))
@@ -1358,7 +1357,7 @@ quickcheck! {
 
         for m in 0..modulo {
             assert_eq!(
-                lookup.get(&m).copied(), 
+                lookup.get(&m).copied(),
                 a.iter()
                     .map(|&b| b as u64)
                     .filter(|&val| val % modulo == m)
@@ -1478,7 +1477,7 @@ quickcheck! {
             assert_eq!(Some(max), a.iter().copied().filter(|&val| val % modulo == key).max_by_key(|&val| val));
         }
     }
-    
+
     fn correct_grouping_map_by_min_modulo_key(a: Vec<u8>, modulo: u8) -> () {
         let modulo = if modulo == 0 { 1 } else { modulo }; // Avoid `% 0`
         let lookup = a.iter().copied().into_grouping_map_by(|i| i % modulo).min();
@@ -1529,7 +1528,7 @@ quickcheck! {
             assert_eq!(Some(min), a.iter().copied().filter(|&val| val % modulo == key).min_by_key(|&val| val));
         }
     }
-    
+
     fn correct_grouping_map_by_minmax_modulo_key(a: Vec<u8>, modulo: u8) -> () {
         let modulo = if modulo == 0 { 1 } else { modulo }; // Avoid `% 0`
         let lookup = a.iter().copied().into_grouping_map_by(|i| i % modulo).minmax();
@@ -1642,7 +1641,7 @@ quickcheck! {
             .min_by(|_, _, _| Ordering::Equal);
 
         assert_eq!(lookup[&0], 0);
-        
+
         let lookup = (0..=10)
             .into_grouping_map_by(|_| 0)
             .minmax_by(|_, _, _| Ordering::Equal);
@@ -1746,7 +1745,7 @@ quickcheck! {
         !is_fused(a.clone().interleave_shortest(b.clone())) &&
         is_fused(a.fuse().interleave_shortest(b.fuse()))
     }
-    
+
     fn fused_product(a: Iter<i16>, b: Iter<i16>) -> bool
     {
         is_fused(a.fuse().cartesian_product(b.fuse()))

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]