refactor default fold, try_fold, rfold and try_rfold implementation to common functions

Author: SkiFire13

library/core/src/iter/traits/double_ended.rs

@@ -214,17 +214,13 @@ pub trait DoubleEndedIterator: Iterator {
     /// ```
     #[inline]
     #[stable(feature = "iterator_try_fold", since = "1.27.0")]
-    fn try_rfold<B, F, R>(&mut self, init: B, mut f: F) -> R
+    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
     where
         Self: Sized,
         F: FnMut(B, Self::Item) -> R,
         R: Try<Ok = B>,
     {
-        let mut accum = init;
-        while let Some(x) = self.next_back() {
-            accum = f(accum, x)?;
-        }
-        try { accum }
+        default_try_rfold(self, init, f)
     }
 
     /// An iterator method that reduces the iterator's elements to a single,
@@ -278,16 +274,12 @@ pub trait DoubleEndedIterator: Iterator {
     /// ```
     #[inline]
     #[stable(feature = "iter_rfold", since = "1.27.0")]
-    fn rfold<B, F>(mut self, init: B, mut f: F) -> B
+    fn rfold<B, F>(self, init: B, f: F) -> B
     where
         Self: Sized,
         F: FnMut(B, Self::Item) -> B,
     {
-        let mut accum = init;
-        while let Some(x) = self.next_back() {
-            accum = f(accum, x);
-        }
-        accum
+        default_rfold(self, init, f)
     }
 
     /// Searches for an element of an iterator from the back that satisfies a predicate.
@@ -349,6 +341,33 @@ pub trait DoubleEndedIterator: Iterator {
     }
 }
 
+#[inline]
+fn default_try_rfold<I, B, F, R>(iter: &mut I, init: B, mut f: F) -> R
+where
+    I: DoubleEndedIterator + ?Sized,
+    F: FnMut(B, I::Item) -> R,
+    R: Try<Ok = B>,
+{
+    let mut accum = init;
+    while let Some(x) = iter.next_back() {
+        accum = f(accum, x)?;
+    }
+    try { accum }
+}
+
+#[inline]
+fn default_rfold<I, B, F>(mut iter: I, init: B, mut f: F) -> B
+where
+    I: DoubleEndedIterator,
+    F: FnMut(B, I::Item) -> B,
+{
+    let mut accum = init;
+    while let Some(x) = iter.next_back() {
+        accum = f(accum, x);
+    }
+    accum
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, I: DoubleEndedIterator + ?Sized> DoubleEndedIterator for &'a mut I {
     fn next_back(&mut self) -> Option<I::Item> {
@@ -389,27 +408,19 @@ trait SpecSizedDoubleEndedIterator: DoubleEndedIterator {
 
 impl<I: DoubleEndedIterator + ?Sized> SpecSizedDoubleEndedIterator for &mut I {
     #[inline]
-    default fn try_rfold<B, F, R>(&mut self, init: B, mut f: F) -> R
+    default fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
     where
         F: FnMut(B, Self::Item) -> R,
         R: Try<Ok = B>,
     {
-        let mut accum = init;
-        while let Some(x) = self.next_back() {
-            accum = f(accum, x)?;
-        }
-        try { accum }
+        default_try_rfold(self, init, f)
     }
     #[inline]
-    default fn rfold<B, F>(mut self, init: B, mut f: F) -> B
+    default fn rfold<B, F>(self, init: B, f: F) -> B
     where
         F: FnMut(B, Self::Item) -> B,
     {
-        let mut accum = init;
-        while let Some(x) = (&mut self).next_back() {
-            accum = f(accum, x);
-        }
-        accum
+        default_rfold(self, init, f)
     }
 }
 

library/core/src/iter/traits/iterator.rs

@@ -1995,17 +1995,13 @@ pub trait Iterator {
     /// ```
     #[inline]
     #[stable(feature = "iterator_try_fold", since = "1.27.0")]
-    fn try_fold<B, F, R>(&mut self, init: B, mut f: F) -> R
+    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
     where
         Self: Sized,
         F: FnMut(B, Self::Item) -> R,
         R: Try<Ok = B>,
     {
-        let mut accum = init;
-        while let Some(x) = self.next() {
-            accum = f(accum, x)?;
-        }
-        try { accum }
+        default_try_fold(self, init, f)
     }
 
     /// An iterator method that applies a fallible function to each item in the
@@ -2136,16 +2132,12 @@ pub trait Iterator {
     #[doc(alias = "inject")]
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn fold<B, F>(mut self, init: B, mut f: F) -> B
+    fn fold<B, F>(self, init: B, f: F) -> B
     where
         Self: Sized,
         F: FnMut(B, Self::Item) -> B,
     {
-        let mut accum = init;
-        while let Some(x) = self.next() {
-            accum = f(accum, x);
-        }
-        accum
+        default_fold(self, init, f)
     }
 
     /// Reduces the elements to a single one, by repeatedly applying a reducing
@@ -3415,6 +3407,33 @@ pub trait Iterator {
     }
 }
 
+#[inline]
+fn default_try_fold<I, B, F, R>(iter: &mut I, init: B, mut f: F) -> R
+where
+    I: Iterator + ?Sized,
+    F: FnMut(B, I::Item) -> R,
+    R: Try<Ok = B>,
+{
+    let mut accum = init;
+    while let Some(x) = iter.next() {
+        accum = f(accum, x)?;
+    }
+    try { accum }
+}
+
+#[inline]
+fn default_fold<I, B, F>(mut iter: I, init: B, mut f: F) -> B
+where
+    I: Iterator,
+    F: FnMut(B, I::Item) -> B,
+{
+    let mut accum = init;
+    while let Some(x) = iter.next() {
+        accum = f(accum, x);
+    }
+    accum
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<I: Iterator + ?Sized> Iterator for &mut I {
     type Item = I::Item;
@@ -3459,27 +3478,19 @@ trait SpecSizedIterator: Iterator {
 
 impl<I: Iterator + ?Sized> SpecSizedIterator for &mut I {
     #[inline]
-    default fn try_fold<B, F, R>(&mut self, init: B, mut f: F) -> R
+    default fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
     where
         F: FnMut(B, Self::Item) -> R,
         R: Try<Ok = B>,
     {
-        let mut accum = init;
-        while let Some(x) = self.next() {
-            accum = f(accum, x)?;
-        }
-        try { accum }
+        default_try_fold(self, init, f)
     }
     #[inline]
-    default fn fold<B, F>(mut self, init: B, mut f: F) -> B
+    default fn fold<B, F>(self, init: B, f: F) -> B
     where
         F: FnMut(B, Self::Item) -> B,
     {
-        let mut accum = init;
-        while let Some(x) = (&mut self).next() {
-            accum = f(accum, x);
-        }
-        accum
+        default_fold(self, init, f)
     }
 }