mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Replace core::iter::AlwaysOk<T> by Result<T, !>

Browse Source
This commit is contained in:
kennytm 2018-05-21 22:50:25 +08:00
parent b68432d560
commit 8ae188959b
No known key found for this signature in database
GPG Key ID: FEF6C8051D0E013C
3 changed files with 4 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/libcore/iter/iterator.rs
View File

@ -11,7 +11,7 @@
use cmp::Ordering;
use ops::Try;
use super::{AlwaysOk, LoopState};
use super::LoopState;
use super::{Chain, Cycle, Cloned, Enumerate, Filter, FilterMap, Fuse};
use super::{Flatten, FlatMap, flatten_compat};
use super::{Inspect, Map, Peekable, Scan, Skip, SkipWhile, StepBy, Take, TakeWhile, Rev};
@ -1614,7 +1614,7 @@ pub trait Iterator {
fn fold<B, F>(mut self, init: B, mut f: F) -> B where
Self: Sized, F: FnMut(B, Self::Item) -> B,
{
self.try_fold(init, move |acc, x| AlwaysOk(f(acc, x))).0
self.try_fold(init, move |acc, x| Ok::<B, !>(f(acc, x))).unwrap()
}
/// Tests if every element of the iterator matches a predicate.

15
src/libcore/iter/mod.rs
View File

@ -354,21 +354,6 @@ mod range;
mod sources;
mod traits;
/// Transparent newtype used to implement foo methods in terms of try_foo.
/// Important until #43278 is fixed; might be better as `Result<T, !>` later.
struct AlwaysOk<T>(pub T);
impl<T> Try for AlwaysOk<T> {
type Ok = T;
type Error = !;
#[inline]
fn into_result(self) -> Result<Self::Ok, Self::Error> { Ok(self.0) }
#[inline]
fn from_error(v: Self::Error) -> Self { v }
#[inline]
fn from_ok(v: Self::Ok) -> Self { AlwaysOk(v) }
}
/// Used to make try_fold closures more like normal loops
#[derive(PartialEq)]
enum LoopState<C, B> {

4
src/libcore/iter/traits.rs
View File

@ -10,7 +10,7 @@
use ops::{Mul, Add, Try};
use num::Wrapping;
use super::{AlwaysOk, LoopState};
use super::LoopState;
/// Conversion from an `Iterator`.
///
@ -524,7 +524,7 @@ pub trait DoubleEndedIterator: Iterator {
fn rfold<B, F>(mut self, accum: B, mut f: F) -> B where
Self: Sized, F: FnMut(B, Self::Item) -> B,
{
self.try_rfold(accum, move |acc, x| AlwaysOk(f(acc, x))).0
self.try_rfold(accum, move |acc, x| Ok::<B, !>(f(acc, x))).unwrap()
}
/// Searches for an element of an iterator from the back that satisfies a predicate.