perf: Let &mut T iterators forward try_fold and friends

Currently `impl Iterator for &mut T` does not forward `try_fold` to the
inner `T` which means that it is easy to lose optimized implementations
of this method and methods that forward to it.

By using specialization on `T: Sized` we can allow calls on non-trait
objects to still forward to the inner methods.

Author: Markus Westerlind

src/libcore/iter/traits/double_ended.rs

@@ -155,17 +155,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::from_ok(accum)
+        try_rfold(self, init, f)
     }
 
     /// An iterator method that reduces the iterator's elements to a single,
@@ -296,6 +292,20 @@ pub trait DoubleEndedIterator: Iterator {
     }
 }
 
+#[inline]
+fn try_rfold<I, B, F, R>(iter: &mut I, init: B, mut f: F) -> R
+where
+    I: DoubleEndedIterator,
+    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::from_ok(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> {
@@ -304,4 +314,27 @@ impl<'a, I: DoubleEndedIterator + ?Sized> DoubleEndedIterator for &'a mut I {
     fn nth_back(&mut self, n: usize) -> Option<I::Item> {
         (**self).nth_back(n)
     }
+
+    #[inline]
+    default 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>,
+    {
+        try_rfold(self, init, f)
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<'a, I: DoubleEndedIterator> DoubleEndedIterator for &'a mut I {
+    #[inline]
+    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>,
+    {
+        (**self).try_rfold(init, f)
+    }
 }

src/libcore/iter/traits/iterator.rs

@@ -1865,17 +1865,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::from_ok(accum)
+        try_fold(self, init, f)
     }
 
     /// An iterator method that applies a fallible function to each item in the
@@ -3224,16 +3220,59 @@ where
     Some(it.fold(first, f))
 }
 
+#[inline]
+fn try_fold<I, B, F, R>(iter: &mut I, init: B, mut f: F) -> R
+where
+    I: Iterator,
+    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::from_ok(accum)
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<I: Iterator + ?Sized> Iterator for &mut I {
     type Item = I::Item;
+
+    #[inline]
     fn next(&mut self) -> Option<I::Item> {
         (**self).next()
     }
+
+    #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
         (**self).size_hint()
     }
+
+    #[inline]
     fn nth(&mut self, n: usize) -> Option<Self::Item> {
         (**self).nth(n)
     }
+
+    #[inline]
+    default fn try_fold<Acc, F, R>(&mut self, init: Acc, f: F) -> R
+    where
+        Self: Sized,
+        F: FnMut(Acc, Self::Item) -> R,
+        R: Try<Ok = Acc>,
+    {
+        try_fold(self, init, f)
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<I: Iterator> Iterator for &mut I {
+    #[inline]
+    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>,
+    {
+        (**self).try_fold(init, f)
+    }
 }