Implement Debug, FusedIterator and Iterator::fold for all `Hash…

…Table` iterators

src/table.rs

@@ -2051,6 +2051,20 @@ impl<T> ExactSizeIterator for IterMut<'_, T> {
 
 impl<T> FusedIterator for IterMut<'_, T> {}
 
+impl<T> fmt::Debug for IterMut<'_, T>
+where
+    T: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list()
+            .entries(Iter {
+                inner: self.inner.clone(),
+                marker: PhantomData,
+            })
+            .finish()
+    }
+}
+
 /// An iterator over the entries of a `HashTable` that could match a given hash.
 /// The iterator element type is `&'a T`.
 ///
@@ -2074,8 +2088,19 @@ impl<'a, T> Iterator for IterHash<'a, T> {
             None => None,
         }
     }
+
+    fn fold<B, F>(self, init: B, mut f: F) -> B
+    where
+        Self: Sized,
+        F: FnMut(B, Self::Item) -> B,
+    {
+        self.inner
+            .fold(init, |acc, bucket| unsafe { f(acc, bucket.as_ref()) })
+    }
 }
 
+impl<T> FusedIterator for IterHash<'_, T> {}
+
 /// A mutable iterator over the entries of a `HashTable` that could match a given hash.
 /// The iterator element type is `&'a mut T`.
 ///
@@ -2099,8 +2124,19 @@ impl<'a, T> Iterator for IterHashMut<'a, T> {
             None => None,
         }
     }
+
+    fn fold<B, F>(self, init: B, mut f: F) -> B
+    where
+        Self: Sized,
+        F: FnMut(B, Self::Item) -> B,
+    {
+        self.inner
+            .fold(init, |acc, bucket| unsafe { f(acc, bucket.as_mut()) })
+    }
 }
 
+impl<T> FusedIterator for IterHashMut<'_, T> {}
+
 /// An owning iterator over the entries of a `HashTable` in arbitrary order.
 /// The iterator element type is `T`.
 ///
@@ -2126,6 +2162,7 @@ impl<T, A: Allocator> Default for IntoIter<T, A> {
         }
     }
 }
+
 impl<T, A> Iterator for IntoIter<T, A>
 where
     A: Allocator,
@@ -2160,6 +2197,21 @@ where
 
 impl<T, A> FusedIterator for IntoIter<T, A> where A: Allocator {}
 
+impl<T, A> fmt::Debug for IntoIter<T, A>
+where
+    T: fmt::Debug,
+    A: Allocator,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list()
+            .entries(Iter {
+                inner: self.inner.iter(),
+                marker: PhantomData,
+            })
+            .finish()
+    }
+}
+
 /// A draining iterator over the items of a `HashTable`.
 ///
 /// This `struct` is created by the [`drain`] method on [`HashTable`].
@@ -2171,36 +2223,42 @@ pub struct Drain<'a, T, A: Allocator = Global> {
     inner: RawDrain<'a, T, A>,
 }
 
-impl<T, A: Allocator> Drain<'_, T, A> {
-    /// Returns a iterator of references over the remaining items.
-    fn iter(&self) -> Iter<'_, T> {
-        Iter {
-            inner: self.inner.iter(),
-            marker: PhantomData,
-        }
-    }
-}
-
 impl<T, A: Allocator> Iterator for Drain<'_, T, A> {
     type Item = T;
 
     fn next(&mut self) -> Option<T> {
         self.inner.next()
     }
+
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.inner.size_hint()
     }
+
+    fn fold<B, F>(self, init: B, f: F) -> B
+    where
+        Self: Sized,
+        F: FnMut(B, Self::Item) -> B,
+    {
+        self.inner.fold(init, f)
+    }
 }
+
 impl<T, A: Allocator> ExactSizeIterator for Drain<'_, T, A> {
     fn len(&self) -> usize {
         self.inner.len()
     }
 }
+
 impl<T, A: Allocator> FusedIterator for Drain<'_, T, A> {}
 
 impl<T: fmt::Debug, A: Allocator> fmt::Debug for Drain<'_, T, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_list().entries(self.iter()).finish()
+        f.debug_list()
+            .entries(Iter {
+                inner: self.inner.iter(),
+                marker: PhantomData,
+            })
+            .finish()
     }
 }