From 05a6185519f3c52a7567dddc57c20399c020d143 Mon Sep 17 00:00:00 2001
From: ltdk <usr@ltdk.xyz>
Date: Mon, 5 Aug 2024 18:21:46 -0400
Subject: [PATCH] Implement Clone, Debug for iterators

---
 src/map.rs     |  3 +++
 src/raw/mod.rs |  1 +
 src/set.rs     |  1 +
 src/table.rs   | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 59 insertions(+)

diff --git a/src/map.rs b/src/map.rs
index 067ade154..616411e1f 100644
--- a/src/map.rs
+++ b/src/map.rs
@@ -2399,6 +2399,7 @@ impl<K, V> IterMut<'_, K, V> {
 /// assert_eq!(iter.next(), None);
 /// assert_eq!(iter.next(), None);
 /// ```
+#[derive(Clone)]
 pub struct IntoIter<K, V, A: Allocator = Global> {
     inner: RawIntoIter<(K, V), A>,
 }
@@ -2443,6 +2444,7 @@ impl<K, V, A: Allocator> IntoIter<K, V, A> {
 /// assert_eq!(keys.next(), None);
 /// assert_eq!(keys.next(), None);
 /// ```
+#[derive(Clone)]
 pub struct IntoKeys<K, V, A: Allocator = Global> {
     inner: IntoIter<K, V, A>,
 }
@@ -2521,6 +2523,7 @@ impl<K: Debug, V: Debug, A: Allocator> fmt::Debug for IntoKeys<K, V, A> {
 /// assert_eq!(values.next(), None);
 /// assert_eq!(values.next(), None);
 /// ```
+#[derive(Clone)]
 pub struct IntoValues<K, V, A: Allocator = Global> {
     inner: IntoIter<K, V, A>,
 }
diff --git a/src/raw/mod.rs b/src/raw/mod.rs
index d69ac59a7..420b4c7e2 100644
--- a/src/raw/mod.rs
+++ b/src/raw/mod.rs
@@ -4280,6 +4280,7 @@ impl ExactSizeIterator for FullBucketsIndices {}
 impl FusedIterator for FullBucketsIndices {}
 
 /// Iterator which consumes a table and returns elements.
+#[derive(Clone)]
 pub struct RawIntoIter<T, A: Allocator = Global> {
     iter: RawIter<T>,
     allocation: Option<(NonNull<u8>, Layout, A)>,
diff --git a/src/set.rs b/src/set.rs
index 6baa2d63a..6bcb8a4bf 100644
--- a/src/set.rs
+++ b/src/set.rs
@@ -1701,6 +1701,7 @@ pub struct Iter<'a, K> {
 ///
 /// [`HashSet`]: struct.HashSet.html
 /// [`into_iter`]: struct.HashSet.html#method.into_iter
+#[derive(Clone)]
 pub struct IntoIter<K, A: Allocator = Global> {
     iter: map::IntoIter<K, (), A>,
 }
diff --git a/src/table.rs b/src/table.rs
index 13f67573b..553460952 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -1835,6 +1835,15 @@ pub struct Iter<'a, T> {
     marker: PhantomData<&'a T>,
 }
 
+impl<'a, T> Clone for Iter<'a, T> {
+    #[cfg_attr(feature = "inline-more", inline)]
+    fn clone(&self) -> Self {
+        Iter {
+            inner: self.inner.clone(),
+            marker: PhantomData,
+        }
+    }
+}
 impl<'a, T> Default for Iter<'a, T> {
     #[cfg_attr(feature = "inline-more", inline)]
     fn default() -> Self {
@@ -1844,6 +1853,11 @@ impl<'a, T> Default for Iter<'a, T> {
         }
     }
 }
+impl<'a, T: fmt::Debug> fmt::Debug for Iter<'a, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list().entries(self.clone()).finish()
+    }
+}
 impl<'a, T> Iterator for Iter<'a, T> {
     type Item = &'a T;
 
@@ -1889,6 +1903,16 @@ pub struct IterMut<'a, T> {
     inner: RawIter<T>,
     marker: PhantomData<&'a mut T>,
 }
+impl<'a, T> IterMut<'a, T> {
+    /// Borrows as a non-mutable iterator.
+    #[cfg_attr(feature = "inline-more", inline)]
+    pub fn iter(&self) -> Iter<'_, T> {
+        Iter {
+            inner: self.inner.clone(),
+            marker: PhantomData,
+        }
+    }
+}
 
 impl<'a, T> Default for IterMut<'a, T> {
     #[cfg_attr(feature = "inline-more", inline)]
@@ -1899,6 +1923,11 @@ impl<'a, T> Default for IterMut<'a, T> {
         }
     }
 }
+impl<'a, T: fmt::Debug> fmt::Debug for IterMut<'a, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list().entries(self.iter()).finish()
+    }
+}
 impl<'a, T> Iterator for IterMut<'a, T> {
     type Item = &'a mut T;
 
@@ -1942,12 +1971,32 @@ impl<T> FusedIterator for IterMut<'_, T> {}
 /// [`into_iter`]: struct.HashTable.html#method.into_iter
 /// [`HashTable`]: struct.HashTable.html
 /// [`IntoIterator`]: https://doc.rust-lang.org/core/iter/trait.IntoIterator.html
+#[derive(Clone)]
 pub struct IntoIter<T, A = Global>
 where
     A: Allocator,
 {
     inner: RawIntoIter<T, A>,
 }
+impl<T, A: Allocator> IntoIter<T, A> {
+    /// Borrows the remaining elements as an iterator.
+    #[cfg_attr(feature = "inline-more", inline)]
+    pub fn iter(&self) -> Iter<'_, T> {
+        Iter {
+            inner: self.inner.iter(),
+            marker: PhantomData,
+        }
+    }
+
+    /// Borrows the remaining elements as a mutable iterator.
+    #[cfg_attr(feature = "inline-more", inline)]
+    pub fn iter_mut(&mut self) -> IterMut<'_, T> {
+        IterMut {
+            inner: self.inner.iter(),
+            marker: PhantomData,
+        }
+    }
+}
 
 impl<T, A: Allocator> Default for IntoIter<T, A> {
     #[cfg_attr(feature = "inline-more", inline)]
@@ -1957,6 +2006,11 @@ impl<T, A: Allocator> Default for IntoIter<T, A> {
         }
     }
 }
+impl<T: fmt::Debug, A: Allocator> fmt::Debug for IntoIter<T, A> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list().entries(self.iter()).finish()
+    }
+}
 impl<T, A> Iterator for IntoIter<T, A>
 where
     A: Allocator,