bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Just delete the overrides now that they match the default implementations

Browse source
This commit is contained in:
Scott McMurray 2019-09-22 21:14:54 -07:00
parent 92e91f7541
commit 6ac64abd6d
1 changed files with 1 additions and 62 deletions
Download patch file Download diff file Expand all files Collapse all files

63
src/libcore/slice/mod.rs
View file

@ -28,7 +28,7 @@ use crate::fmt;
use crate::intrinsics::{assume, exact_div, unchecked_sub, is_aligned_and_not_null};
use crate::isize;
use crate::iter::*;
use crate::ops::{FnMut, Try, self};
use crate::ops::{FnMut, self};
use crate::option::Option;
use crate::option::Option::{None, Some};
use crate::result::Result;
@ -3180,33 +3180,6 @@ macro_rules! iterator {
self.next_back()
}
#[inline]
fn try_fold<B, F, R>(&mut self, init: B, mut f: F) -> R where
Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Ok=B>
{
// This method historically was unrolled, for as of 2019-09 LLVM
// is not capable of unrolling or vectorizing multiple-exit loops.
// However, doing it always proved to often be a pessimization,
// especially when called with large closures, so it was removed.
let mut accum = init;
while let Some(x) = self.next() {
accum = f(accum, x)?;
}
Try::from_ok(accum)
}
#[inline]
fn fold<Acc, Fold>(mut self, init: Acc, mut f: Fold) -> Acc
where Fold: FnMut(Acc, Self::Item) -> Acc,
{
let mut accum = init;
while let Some(x) = self.next() {
accum = f(accum, x);
}
accum
}
#[inline]
#[rustc_inherit_overflow_checks]
fn position<P>(&mut self, mut predicate: P) -> Option<usize> where
@ -3277,40 +3250,6 @@ macro_rules! iterator {
Some(next_back_unchecked!(self))
}
}
#[inline]
fn try_rfold<B, F, R>(&mut self, init: B, mut f: F) -> R where
Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Ok=B>
{
// manual unrolling is needed when there are conditional exits from the loop
let mut accum = init;
unsafe {
while len!(self) >= 4 {
accum = f(accum, next_back_unchecked!(self))?;
accum = f(accum, next_back_unchecked!(self))?;
accum = f(accum, next_back_unchecked!(self))?;
accum = f(accum, next_back_unchecked!(self))?;
}
// inlining is_empty everywhere makes a huge performance difference
while !is_empty!(self) {
accum = f(accum, next_back_unchecked!(self))?;
}
}
Try::from_ok(accum)
}
#[inline]
fn rfold<Acc, Fold>(mut self, init: Acc, mut f: Fold) -> Acc
where Fold: FnMut(Acc, Self::Item) -> Acc,
{
// Let LLVM unroll this, rather than using the default
// impl that would force the manual unrolling above
let mut accum = init;
while let Some(x) = self.next_back() {
accum = f(accum, x);
}
accum
}
}
#[stable(feature = "fused", since = "1.26.0")]