Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

perf: Let &mut T iterators forward for_each and friends #68472

Closed
wants to merge 1 commit into from
Closed

perf: Let &mut T iterators forward for_each and friends #68472

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
45 changes: 39 additions & 6 deletions src/libcore/iter/traits/double_ended.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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,
Expand Down Expand Up @@ -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> {
Expand All @@ -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)
}
}
51 changes: 45 additions & 6 deletions src/libcore/iter/traits/iterator.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down Expand Up @@ -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]
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Have you measured the impact of these inline attributes you are adding? I'd prefer not to use #[inline] unless we are pretty sure it leads to faster code somewhere.

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I thought #[inline] is a sensible default because it lets LLVM decide whether to inline or not, and all iterator methods in libcore that I can find have this attribute.

Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

AFAIK (we really need a de-facto standard guide on inline...) that they are not necessary on generic items as their definitions will be available in downstream crates anyway.

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

That is correct, but next itself isn't generic, so I believe here it does make a difference? And afaik for generic functions the attribute is ignored, so adding it shouldn't hurt.

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)
}
}