Add derive(Clone) where possible

Signed-off-by: Anders Kaseorg <[email protected]>

Author: andersk

src/adaptors/mod.rs

@@ -886,7 +886,7 @@ impl<I, A> Iterator for WhileSome<I>
 ///
 /// See [`.tuple_combinations()`](../trait.Itertools.html#method.tuple_combinations) for more
 /// information.
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 pub struct TupleCombinations<I, T>
     where I: Iterator,
@@ -925,7 +925,7 @@ impl<I, T> Iterator for TupleCombinations<I, T>
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Tuple1Combination<I> {
     iter: I,
 }
@@ -950,7 +950,7 @@ impl<I: Iterator> HasCombination<I> for (I::Item,) {
 
 macro_rules! impl_tuple_combination {
     ($C:ident $P:ident ; $A:ident, $($I:ident),* ; $($X:ident)*) => (
-        #[derive(Debug)]
+        #[derive(Clone, Debug)]
         pub struct $C<I: Iterator> {
             item: Option<I::Item>,
             iter: I,
@@ -1014,6 +1014,7 @@ impl_tuple_combination!(Tuple4Combination Tuple3Combination ; A, A, A, A, A; a b
 /// An iterator adapter to apply `Into` conversion to each element.
 ///
 /// See [`.map_into()`](../trait.Itertools.html#method.map_into) for more information.
+#[derive(Clone)]
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 pub struct MapInto<I, R> {
     iter: I,
@@ -1071,6 +1072,7 @@ where
 /// An iterator adapter to apply a transformation within a nested `Result`.
 ///
 /// See [`.map_results()`](../trait.Itertools.html#method.map_results) for more information.
+#[derive(Clone)]
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 pub struct MapResults<I, F> {
     iter: I,
@@ -1120,6 +1122,7 @@ impl<I, F, T, U, E> Iterator for MapResults<I, F>
 /// An iterator adapter to get the positions of each element that matches a predicate.
 ///
 /// See [`.positions()`](../trait.Itertools.html#method.positions) for more information.
+#[derive(Clone)]
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 pub struct Positions<I, F> {
     iter: I,
@@ -1178,6 +1181,7 @@ impl<I, F> DoubleEndedIterator for Positions<I, F>
 /// An iterator adapter to apply a mutating function to each element before yielding it.
 ///
 /// See [`.update()`](../trait.Itertools.html#method.update) for more information.
+#[derive(Clone)]
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 pub struct Update<I, F> {
     iter: I,

src/combinations.rs

@@ -13,6 +13,20 @@ pub struct Combinations<I: Iterator> {
     first: bool,
 }
 
+impl<I> Clone for Combinations<I>
+    where I: Clone + Iterator,
+          I::Item: Clone,
+{
+    fn clone(&self) -> Self {
+        Combinations {
+            k: self.k,
+            indices: self.indices.clone(),
+            pool: self.pool.clone(),
+            first: self.first,
+        }
+    }
+}
+
 impl<I> fmt::Debug for Combinations<I>
     where I: Iterator + fmt::Debug,
           I::Item: fmt::Debug,

src/format.rs

@@ -7,6 +7,7 @@ use std::cell::RefCell;
 /// exhausted.
 ///
 /// See [`.format_with()`](../trait.Itertools.html#method.format_with) for more information.
+#[derive(Clone)]
 pub struct FormatWith<'a, I, F> {
     sep: &'a str,
     /// FormatWith uses interior mutability because Display::fmt takes &self.

src/merge_join.rs

@@ -31,6 +31,22 @@ pub struct MergeJoinBy<I: Iterator, J: Iterator, F> {
     cmp_fn: F
 }
 
+impl<I, J, F> Clone for MergeJoinBy<I, J, F>
+    where I: Clone + Iterator,
+          I::Item: Clone,
+          J: Clone + Iterator,
+          J::Item: Clone,
+          F: Clone,
+{
+    fn clone(&self) -> Self {
+        MergeJoinBy {
+            left: self.left.clone(),
+            right: self.right.clone(),
+            cmp_fn: self.cmp_fn.clone(),
+        }
+    }
+}
+
 impl<I, J, F> fmt::Debug for MergeJoinBy<I, J, F>
     where I: Iterator + fmt::Debug,
           I::Item: fmt::Debug,

src/permutations.rs

@@ -14,7 +14,19 @@ pub struct Permutations<I: Iterator> {
     state: PermutationState,
 }
 
-#[derive(Debug)]
+impl<I> Clone for Permutations<I>
+    where I: Clone + Iterator,
+          I::Item: Clone,
+{
+    fn clone(&self) -> Self {
+        Permutations {
+            vals: self.vals.clone(),
+            state: self.state.clone(),
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
 enum PermutationState {
     StartUnknownLen {
         k: usize,
@@ -27,7 +39,7 @@ enum PermutationState {
     Empty,
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 enum CompleteState {
     Start {
         n: usize,

src/repeatn.rs

@@ -3,7 +3,7 @@
 ///
 /// See [`repeat_n()`](../fn.repeat_n.html) for more information.
 #[must_use = "iterators are lazy and do nothing unless consumed"]
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct RepeatN<A> {
     elt: Option<A>,
     n: usize,

src/sources.rs

@@ -6,6 +6,7 @@ use std::fmt;
 use std::mem;
 
 /// See [`repeat_call`](../fn.repeat_call.html) for more information.
+#[derive(Clone)]
 #[deprecated(note="Use std repeat_with() instead", since="0.8")]
 pub struct RepeatCall<F> {
     f: F,

src/tuple_impl.rs

@@ -6,7 +6,7 @@ use std::iter::Fuse;
 ///
 /// See [`.tuples()`](../trait.Itertools.html#method.tuples) and
 /// [`Tuples::into_buffer()`](struct.Tuples.html#method.into_buffer).
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct TupleBuffer<T>
     where T: TupleCollect
 {
@@ -61,6 +61,7 @@ impl<T> ExactSizeIterator for TupleBuffer<T>
 /// An iterator that groups the items in tuples of a specific size.
 ///
 /// See [`.tuples()`](../trait.Itertools.html#method.tuples) for more information.
+#[derive(Clone)]
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 pub struct Tuples<I, T>
     where I: Iterator<Item = T::Item>,
@@ -117,7 +118,7 @@ impl<I, T> Tuples<I, T>
 /// See [`.tuple_windows()`](../trait.Itertools.html#method.tuple_windows) for more
 /// information.
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct TupleWindows<I, T>
     where I: Iterator<Item = T::Item>,
           T: TupleCollect

src/with_position.rs

@@ -13,6 +13,18 @@ pub struct WithPosition<I>
     peekable: Peekable<Fuse<I>>,
 }
 
+impl<I> Clone for WithPosition<I>
+    where I: Clone + Iterator,
+          I::Item: Clone,
+{
+    fn clone(&self) -> Self {
+        WithPosition {
+            handled_first: self.handled_first,
+            peekable: self.peekable.clone(),
+        }
+    }
+}
+
 /// Create a new `WithPosition` iterator.
 pub fn with_position<I>(iter: I) -> WithPosition<I>
     where I: Iterator,