Specialize TupleCombinations::fold

benches/bench1.rs

@@ -855,6 +855,17 @@ fn with_position_fold(c: &mut Criterion) {
     });
 }
 
+fn tuple_combinations_fold(c: &mut Criterion) {
+    let v = black_box((0..64).collect_vec());
+    c.bench_function("tuple_combinations fold", move |b| {
+        b.iter(|| {
+            v.iter()
+                .tuple_combinations()
+                .fold(0, |acc, (a, b, c, d)| acc + *a * *c - *b * *d)
+        })
+    });
+}
+
 criterion_group!(
     benches,
     slice_iter,
@@ -903,6 +914,7 @@ criterion_group!(
     permutations_range,
     permutations_slice,
     with_position_fold,
+    tuple_combinations_fold,
     while_some,
 );
 criterion_main!(benches);

src/adaptors/mod.rs

@@ -650,6 +650,13 @@ where
     fn count(self) -> usize {
         self.iter.count()
     }
+
+    fn fold<B, F>(self, init: B, f: F) -> B
+    where
+        F: FnMut(B, Self::Item) -> B,
+    {
+        self.iter.fold(init, f)
+    }
 }
 
 impl<I, T> FusedIterator for TupleCombinations<I, T>
@@ -684,6 +691,13 @@ impl<I: Iterator> Iterator for Tuple1Combination<I> {
     fn count(self) -> usize {
         self.iter.count()
     }
+
+    fn fold<B, F>(self, init: B, f: F) -> B
+    where
+        F: FnMut(B, Self::Item) -> B,
+    {
+        self.iter.map(|x| (x,)).fold(init, f)
+    }
 }
 
 impl<I: Iterator> HasCombination<I> for (I::Item,) {
@@ -717,7 +731,7 @@ macro_rules! impl_tuple_combination {
 
         impl<I, A> Iterator for $C<I>
             where I: Iterator<Item = A> + Clone,
-                  I::Item: Clone
+                  A: Clone,
         {
             type Item = (A, $(ignore_ident!($X, A)),*);
 
@@ -747,6 +761,26 @@ macro_rules! impl_tuple_combination {
                 let n = self.iter.count();
                 checked_binomial(n, K).unwrap() + self.c.count()
             }
+
+            fn fold<B, F>(self, mut init: B, mut f: F) -> B
+            where
+                F: FnMut(B, Self::Item) -> B,
+            {
+                let Self { c, item, mut iter } = self;
+                init = c
+                    .map(|($($X),*,)| {
+                        let z = item.clone().unwrap();
+                        (z, $($X),*)
+                    })
+                    .fold(init, &mut f);
+                while let Some(z) = iter.next() {
+                    let c: $P<I> = iter.clone().into();
+                    init = c
+                        .map(|($($X),*,)| (z.clone(), $($X),*))
+                        .fold(init, &mut f);
+                }
+                init
+            }
         }
 
         impl<I, A> HasCombination<I> for (A, $(ignore_ident!($X, A)),*)