Rollup merge of rust-lang#160342 - a1phyr:fuse_advnce_by, r=joboet

Specialize `advance_by` method of `Fuse`

`advance_by` is used a lot internally so it seems important to specialize it.

Author: jhpratt

library/core/src/iter/adapters/fuse.rs

@@ -4,6 +4,7 @@ use crate::iter::adapters::zip::try_get_unchecked;
 use crate::iter::{
     FusedIterator, TrustedFused, TrustedLen, TrustedRandomAccess, TrustedRandomAccessNoCoerce,
 };
+use crate::num::NonZero;
 use crate::ops::Try;
 
 /// An iterator that yields `None` forever after the underlying iterator
@@ -50,6 +51,10 @@ where
         FuseImpl::next(self)
     }
 
+    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+        FuseImpl::advance_by(self, n)
+    }
+
     #[inline]
     fn nth(&mut self, n: usize) -> Option<I::Item> {
         FuseImpl::nth(self, n)
@@ -259,6 +264,7 @@ trait FuseImpl<I> {
 
     // Functions specific to any normal Iterators
     fn next(&mut self) -> Option<Self::Item>;
+    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>;
     fn nth(&mut self, n: usize) -> Option<Self::Item>;
     fn try_fold<Acc, Fold, R>(&mut self, acc: Acc, fold: Fold) -> R
     where
@@ -301,6 +307,22 @@ where
         and_then_or_clear(&mut self.iter, Iterator::next)
     }
 
+    #[inline]
+    default fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+        let Some(iter) = &mut self.iter else {
+            return match NonZero::new(n) {
+                Some(n) => Err(n),
+                None => Ok(()),
+            };
+        };
+
+        let res = iter.advance_by(n);
+        if res.is_err() {
+            self.iter = None;
+        }
+        res
+    }
+
     #[inline]
     default fn nth(&mut self, n: usize) -> Option<I::Item> {
         and_then_or_clear(&mut self.iter, |iter| iter.nth(n))
@@ -381,6 +403,17 @@ where
         self.iter.as_mut()?.next()
     }
 
+    #[inline]
+    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+        match &mut self.iter {
+            Some(iter) => iter.advance_by(n),
+            None => match NonZero::new(n) {
+                Some(n) => Err(n),
+                None => Ok(()),
+            },
+        }
+    }
+
     #[inline]
     fn nth(&mut self, n: usize) -> Option<I::Item> {
         self.iter.as_mut()?.nth(n)