Override iterator fold and rfold

These benefit from internal iteration over just the head and then the
tail, or vice versa. The `iter_sum_ringmap_10_000` benchmark is about
twice as fast with this change!

Author: cuviper

src/macros.rs

@@ -98,6 +98,13 @@ macro_rules! iterator_methods {
             self.next_back()
         }
 
+        fn fold<Acc, F>(self, acc: Acc, f: F) -> Acc
+        where
+            F: FnMut(Acc, Self::Item) -> Acc,
+        {
+            self.iter.map($map_elt).fold(acc, f)
+        }
+
         fn collect<C>(self) -> C
         where
             C: FromIterator<Self::Item>,
@@ -120,6 +127,13 @@ macro_rules! double_ended_iterator_methods {
         fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
             self.iter.nth_back(n).map($map_elt)
         }
+
+        fn rfold<Acc, F>(self, acc: Acc, f: F) -> Acc
+        where
+            F: FnMut(Acc, Self::Item) -> Acc,
+        {
+            self.iter.map($map_elt).rfold(acc, f)
+        }
     };
 }
 

src/map/iter.rs

@@ -92,6 +92,14 @@ impl<'a, K, V> Iterator for Buckets<'a, K, V> {
         self.next_back()
     }
 
+    fn fold<Acc, F>(self, mut acc: Acc, mut f: F) -> Acc
+    where
+        F: FnMut(Acc, Self::Item) -> Acc,
+    {
+        acc = self.head.fold(acc, &mut f);
+        self.tail.fold(acc, &mut f)
+    }
+
     fn collect<C>(self) -> C
     where
         C: FromIterator<Self::Item>,
@@ -118,6 +126,14 @@ impl<K, V> DoubleEndedIterator for Buckets<'_, K, V> {
         }
         self.head.nth_back(n)
     }
+
+    fn rfold<Acc, F>(self, mut acc: Acc, mut f: F) -> Acc
+    where
+        F: FnMut(Acc, Self::Item) -> Acc,
+    {
+        acc = self.tail.rfold(acc, &mut f);
+        self.head.rfold(acc, &mut f)
+    }
 }
 
 impl<K, V> ExactSizeIterator for Buckets<'_, K, V> {
@@ -208,6 +224,14 @@ impl<'a, K, V> Iterator for BucketsMut<'a, K, V> {
         self.next_back()
     }
 
+    fn fold<Acc, F>(self, acc: Acc, mut f: F) -> Acc
+    where
+        F: FnMut(Acc, Self::Item) -> Acc,
+    {
+        let acc = self.head.fold(acc, &mut f);
+        self.tail.fold(acc, &mut f)
+    }
+
     fn collect<C>(self) -> C
     where
         C: FromIterator<Self::Item>,
@@ -234,6 +258,14 @@ impl<K, V> DoubleEndedIterator for BucketsMut<'_, K, V> {
         }
         self.head.nth_back(n)
     }
+
+    fn rfold<Acc, F>(self, acc: Acc, mut f: F) -> Acc
+    where
+        F: FnMut(Acc, Self::Item) -> Acc,
+    {
+        let acc = self.tail.rfold(acc, &mut f);
+        self.head.rfold(acc, &mut f)
+    }
 }
 
 impl<K, V> ExactSizeIterator for BucketsMut<'_, K, V> {