From 3dab85526024851a7ef9776cc9375d5a3311609b Mon Sep 17 00:00:00 2001
From: Easyoakland <97992568+Easyoakland@users.noreply.github.com>
Date: Tue, 21 Mar 2023 19:28:41 -0600
Subject: [PATCH 1/3] Added derive clone to Chunks.

---
 src/groupbylazy.rs | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/groupbylazy.rs b/src/groupbylazy.rs
index a5a321df4..80c6f09f3 100644
--- a/src/groupbylazy.rs
+++ b/src/groupbylazy.rs
@@ -19,7 +19,7 @@ impl<A, K, F: ?Sized> KeyFunction<A> for F
 
 
 /// `ChunkIndex` acts like the grouping key function for `IntoChunks`
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 struct ChunkIndex {
     size: usize,
     index: usize,
@@ -50,7 +50,7 @@ impl<A> KeyFunction<A> for ChunkIndex {
     }
 }
 
-
+#[derive(Clone)]
 struct GroupInner<K, I, F>
     where I: Iterator
 {
@@ -471,6 +471,13 @@ pub struct IntoChunks<I>
     index: Cell<usize>,
 }
 
+impl<I> Clone for IntoChunks<I>
+    where I: Clone + Iterator,
+          I::Item: Clone,
+{
+    clone_fields!(inner, index);
+}
+
 
 impl<I> IntoChunks<I>
     where I: Iterator,
@@ -507,6 +514,7 @@ impl<'a, I> IntoIterator for &'a IntoChunks<I>
 ///
 /// See [`.chunks()`](crate::Itertools::chunks) for more information.
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Clone)]
 pub struct Chunks<'a, I: 'a>
     where I: Iterator,
           I::Item: 'a,

From e01a74b55dfa7ca129c17ee430c97818fd4aa646 Mon Sep 17 00:00:00 2001
From: Easyoakland <97992568+Easyoakland@users.noreply.github.com>
Date: Tue, 21 Mar 2023 19:46:30 -0600
Subject: [PATCH 2/3] Added test that `Chunks` clone works correctly.

---
 tests/test_std.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/tests/test_std.rs b/tests/test_std.rs
index 77207d87e..0ea01408b 100644
--- a/tests/test_std.rs
+++ b/tests/test_std.rs
@@ -842,6 +842,7 @@ fn group_by_lazy_3() {
 fn chunks() {
     let data = vec![0, 0, 0, 1, 1, 0, 0, 2, 2, 3, 3];
     let grouper = data.iter().chunks(3);
+    let grouper_clone = grouper.clone();
     for (i, chunk) in grouper.into_iter().enumerate() {
         match i {
             0 => it::assert_equal(chunk, &[0, 0, 0]),
@@ -851,6 +852,15 @@ fn chunks() {
             _ => unreachable!(),
         }
     }
+    for (i, chunk) in grouper_clone.into_iter().enumerate() {
+        match i {
+            0 => it::assert_equal(chunk, &[0, 0, 0]),
+            1 => it::assert_equal(chunk, &[1, 1, 0]),
+            2 => it::assert_equal(chunk, &[0, 2, 2]),
+            3 => it::assert_equal(chunk, &[3, 3]),
+            _ => unreachable!(),
+        }
+    }
 }
 
 #[test]

From d6082831e7f2f80723bf0caf04703a62c5b0faae Mon Sep 17 00:00:00 2001
From: Easyoakland <97992568+Easyoakland@users.noreply.github.com>
Date: Thu, 23 Mar 2023 14:42:34 -0600
Subject: [PATCH 3/3] Changed chunk clone test to quicktest.

---
 tests/quick.rs    | 11 +++++++++++
 tests/test_std.rs | 10 ----------
 2 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/tests/quick.rs b/tests/quick.rs
index 0adcf1ad7..7af0ef602 100644
--- a/tests/quick.rs
+++ b/tests/quick.rs
@@ -993,6 +993,17 @@ quickcheck! {
     }
 }
 
+quickcheck! {
+    fn chunk_clone_equal(a: Vec<u8>, size: u8) -> () {
+        let mut size = size;
+        if size == 0 {
+            size += 1;
+        }
+        let it = a.chunks(size as usize);
+        itertools::assert_equal(it.clone(), it);
+    }
+}
+
 quickcheck! {
     fn equal_chunks_lazy(a: Vec<u8>, size: u8) -> bool {
         let mut size = size;
diff --git a/tests/test_std.rs b/tests/test_std.rs
index 0ea01408b..77207d87e 100644
--- a/tests/test_std.rs
+++ b/tests/test_std.rs
@@ -842,7 +842,6 @@ fn group_by_lazy_3() {
 fn chunks() {
     let data = vec![0, 0, 0, 1, 1, 0, 0, 2, 2, 3, 3];
     let grouper = data.iter().chunks(3);
-    let grouper_clone = grouper.clone();
     for (i, chunk) in grouper.into_iter().enumerate() {
         match i {
             0 => it::assert_equal(chunk, &[0, 0, 0]),
@@ -852,15 +851,6 @@ fn chunks() {
             _ => unreachable!(),
         }
     }
-    for (i, chunk) in grouper_clone.into_iter().enumerate() {
-        match i {
-            0 => it::assert_equal(chunk, &[0, 0, 0]),
-            1 => it::assert_equal(chunk, &[1, 1, 0]),
-            2 => it::assert_equal(chunk, &[0, 2, 2]),
-            3 => it::assert_equal(chunk, &[3, 3]),
-            _ => unreachable!(),
-        }
-    }
 }
 
 #[test]