diff --git a/library/core/src/iter/adapters/mod.rs b/library/core/src/iter/adapters/mod.rs index 1e520b62f77c4..422e449b176b7 100644 --- a/library/core/src/iter/adapters/mod.rs +++ b/library/core/src/iter/adapters/mod.rs @@ -124,11 +124,6 @@ where self.iter.size_hint() } - #[inline] - fn advance_by(&mut self, n: usize) -> Result<(), usize> { - self.iter.advance_back_by(n) - } - #[inline] fn nth(&mut self, n: usize) -> Option<::Item> { self.iter.nth_back(n) @@ -169,11 +164,6 @@ where self.iter.next() } - #[inline] - fn advance_back_by(&mut self, n: usize) -> Result<(), usize> { - self.iter.advance_by(n) - } - #[inline] fn nth_back(&mut self, n: usize) -> Option<::Item> { self.iter.nth(n) diff --git a/library/core/src/iter/traits/double_ended.rs b/library/core/src/iter/traits/double_ended.rs index 16bee0e2eee18..bc03c143d6afb 100644 --- a/library/core/src/iter/traits/double_ended.rs +++ b/library/core/src/iter/traits/double_ended.rs @@ -91,46 +91,6 @@ pub trait DoubleEndedIterator: Iterator { #[stable(feature = "rust1", since = "1.0.0")] fn next_back(&mut self) -> Option; - /// Advances the iterator from the back by `n` elements. - /// - /// `advance_back_by` is the reverse version of [`advance_by`]. This method will - /// eagerly skip `n` elements starting from the back by calling [`next_back`] up - /// to `n` times until [`None`] is encountered. - /// - /// `advance_back_by(n)` will return [`Ok(())`] if the iterator successfully advances by - /// `n` elements, or [`Err(k)`] if [`None`] is encountered, where `k` is the number of - /// elements the iterator is advanced by before running out of elements (i.e. the length - /// of the iterator). Note that `k` is always less than `n`. - /// - /// Calling `advance_back_by(0)` does not consume any elements and always returns [`Ok(())`]. - /// - /// [`advance_by`]: Iterator::advance_by - /// [`next_back`]: DoubleEndedIterator::next_back - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// #![feature(iter_advance_by)] - /// - /// let a = [3, 4, 5, 6]; - /// let mut iter = a.iter(); - /// - /// assert_eq!(iter.advance_back_by(2), Ok(())); - /// assert_eq!(iter.next_back(), Some(&4)); - /// assert_eq!(iter.advance_back_by(0), Ok(())); - /// assert_eq!(iter.advance_back_by(100), Err(1)); // only `&3` was skipped - /// ``` - #[inline] - #[unstable(feature = "iter_advance_by", reason = "recently added", issue = "77404")] - fn advance_back_by(&mut self, n: usize) -> Result<(), usize> { - for i in 0..n { - self.next_back().ok_or(i)?; - } - Ok(()) - } - /// Returns the `n`th element from the end of the iterator. /// /// This is essentially the reversed version of [`Iterator::nth()`]. @@ -174,9 +134,14 @@ pub trait DoubleEndedIterator: Iterator { /// ``` #[inline] #[stable(feature = "iter_nth_back", since = "1.37.0")] - fn nth_back(&mut self, n: usize) -> Option { - self.advance_back_by(n).ok()?; - self.next_back() + fn nth_back(&mut self, mut n: usize) -> Option { + for x in self.rev() { + if n == 0 { + return Some(x); + } + n -= 1; + } + None } /// This is the reverse version of [`Iterator::try_fold()`]: it takes @@ -353,9 +318,6 @@ impl<'a, I: DoubleEndedIterator + ?Sized> DoubleEndedIterator for &'a mut I { fn next_back(&mut self) -> Option { (**self).next_back() } - fn advance_back_by(&mut self, n: usize) -> Result<(), usize> { - (**self).advance_back_by(n) - } fn nth_back(&mut self, n: usize) -> Option { (**self).nth_back(n) } diff --git a/library/core/src/iter/traits/iterator.rs b/library/core/src/iter/traits/iterator.rs index 813afcc0ec6e4..845df3f5ca551 100644 --- a/library/core/src/iter/traits/iterator.rs +++ b/library/core/src/iter/traits/iterator.rs @@ -284,44 +284,6 @@ pub trait Iterator { self.fold(None, some) } - /// Advances the iterator by `n` elements. - /// - /// This method will eagerly skip `n` elements by calling [`next`] up to `n` - /// times until [`None`] is encountered. - /// - /// `advance_by(n)` will return [`Ok(())`] if the iterator successfully advances by - /// `n` elements, or [`Err(k)`] if [`None`] is encountered, where `k` is the number - /// of elements the iterator is advanced by before running out of elements (i.e. the - /// length of the iterator). Note that `k` is always less than `n`. - /// - /// Calling `advance_by(0)` does not consume any elements and always returns [`Ok(())`]. - /// - /// [`next`]: Iterator::next - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// #![feature(iter_advance_by)] - /// - /// let a = [1, 2, 3, 4]; - /// let mut iter = a.iter(); - /// - /// assert_eq!(iter.advance_by(2), Ok(())); - /// assert_eq!(iter.next(), Some(&3)); - /// assert_eq!(iter.advance_by(0), Ok(())); - /// assert_eq!(iter.advance_by(100), Err(1)); // only `&4` was skipped - /// ``` - #[inline] - #[unstable(feature = "iter_advance_by", reason = "recently added", issue = "77404")] - fn advance_by(&mut self, n: usize) -> Result<(), usize> { - for i in 0..n { - self.next().ok_or(i)?; - } - Ok(()) - } - /// Returns the `n`th element of the iterator. /// /// Like most indexing operations, the count starts from zero, so `nth(0)` @@ -363,9 +325,14 @@ pub trait Iterator { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - fn nth(&mut self, n: usize) -> Option { - self.advance_by(n).ok()?; - self.next() + fn nth(&mut self, mut n: usize) -> Option { + while let Some(x) = self.next() { + if n == 0 { + return Some(x); + } + n -= 1; + } + None } /// Creates an iterator starting at the same point, but stepping by @@ -3298,9 +3265,6 @@ impl Iterator for &mut I { fn size_hint(&self) -> (usize, Option) { (**self).size_hint() } - fn advance_by(&mut self, n: usize) -> Result<(), usize> { - (**self).advance_by(n) - } fn nth(&mut self, n: usize) -> Option { (**self).nth(n) } diff --git a/library/core/tests/iter.rs b/library/core/tests/iter.rs index b15d6d1b1f613..ab97352a806ad 100644 --- a/library/core/tests/iter.rs +++ b/library/core/tests/iter.rs @@ -1570,66 +1570,6 @@ fn test_iterator_rev_nth() { assert_eq!(v.iter().rev().nth(v.len()), None); } -#[test] -fn test_iterator_advance_by() { - let v: &[_] = &[0, 1, 2, 3, 4]; - - for i in 0..v.len() { - let mut iter = v.iter(); - assert_eq!(iter.advance_by(i), Ok(())); - assert_eq!(iter.next().unwrap(), &v[i]); - assert_eq!(iter.advance_by(100), Err(v.len() - 1 - i)); - } - - assert_eq!(v.iter().advance_by(v.len()), Ok(())); - assert_eq!(v.iter().advance_by(100), Err(v.len())); -} - -#[test] -fn test_iterator_advance_back_by() { - let v: &[_] = &[0, 1, 2, 3, 4]; - - for i in 0..v.len() { - let mut iter = v.iter(); - assert_eq!(iter.advance_back_by(i), Ok(())); - assert_eq!(iter.next_back().unwrap(), &v[v.len() - 1 - i]); - assert_eq!(iter.advance_back_by(100), Err(v.len() - 1 - i)); - } - - assert_eq!(v.iter().advance_back_by(v.len()), Ok(())); - assert_eq!(v.iter().advance_back_by(100), Err(v.len())); -} - -#[test] -fn test_iterator_rev_advance_by() { - let v: &[_] = &[0, 1, 2, 3, 4]; - - for i in 0..v.len() { - let mut iter = v.iter().rev(); - assert_eq!(iter.advance_by(i), Ok(())); - assert_eq!(iter.next().unwrap(), &v[v.len() - 1 - i]); - assert_eq!(iter.advance_by(100), Err(v.len() - 1 - i)); - } - - assert_eq!(v.iter().rev().advance_by(v.len()), Ok(())); - assert_eq!(v.iter().rev().advance_by(100), Err(v.len())); -} - -#[test] -fn test_iterator_rev_advance_back_by() { - let v: &[_] = &[0, 1, 2, 3, 4]; - - for i in 0..v.len() { - let mut iter = v.iter().rev(); - assert_eq!(iter.advance_back_by(i), Ok(())); - assert_eq!(iter.next_back().unwrap(), &v[i]); - assert_eq!(iter.advance_back_by(100), Err(v.len() - 1 - i)); - } - - assert_eq!(v.iter().rev().advance_back_by(v.len()), Ok(())); - assert_eq!(v.iter().rev().advance_back_by(100), Err(v.len())); -} - #[test] fn test_iterator_last() { let v: &[_] = &[0, 1, 2, 3, 4]; diff --git a/library/core/tests/lib.rs b/library/core/tests/lib.rs index 0c4ce867f542d..8d86349244b09 100644 --- a/library/core/tests/lib.rs +++ b/library/core/tests/lib.rs @@ -41,7 +41,6 @@ #![feature(slice_partition_dedup)] #![feature(int_error_matching)] #![feature(array_value_iter)] -#![feature(iter_advance_by)] #![feature(iter_partition_in_place)] #![feature(iter_is_partitioned)] #![feature(iter_order_by)]