Tuple*Combinations::fold (macro)

`I::Item` and `A` are the same so the "where condition" is not really changed, but it is apparently needed here.
We fold `c` then for each item of `iter`, we fold the cloned `iter`.
The `while let` loop should probably be converted to `fold` somehow later (if possible) but the core logic is done and it is already really faster.

Author: Philippe-Cholet

src/adaptors/mod.rs

@@ -731,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)),*);
 
@@ -761,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)),*)