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

Bootstrapping preparation for the library

Browse Source 
Since just `ops::Try` will need to change meaning.
This commit is contained in:
Scott McMurray 2021-04-14 16:40:23 -07:00
parent d44f647ffc
commit c10eec3a1c
33 changed files with 123 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
library/alloc/src/collections/vec_deque/iter.rs
View File

@ -1,6 +1,6 @@
use core::fmt;
use core::iter::{FusedIterator, TrustedLen, TrustedRandomAccess};
use core::ops::Try;
use core::ops::TryWhereOutputEquals;
use super::{count, wrap_index, RingSlices};
@ -66,7 +66,7 @@ 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>,
R: TryWhereOutputEquals<B>,
{
let (mut iter, final_res);
if self.tail <= self.head {
@ -140,7 +140,7 @@ 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>,
R: TryWhereOutputEquals<B>,
{
let (mut iter, final_res);
if self.tail <= self.head {

1
library/alloc/src/lib.rs
View File

@ -141,6 +141,7 @@
#![feature(alloc_layout_extra)]
#![feature(trusted_random_access)]
#![feature(try_trait)]
#![feature(try_trait_transition)]
#![feature(min_type_alias_impl_trait)]
#![feature(associated_type_bounds)]
#![feature(slice_group_by)]

6
library/core/src/iter/adapters/chain.rs
View File

@ -1,5 +1,5 @@
use crate::iter::{DoubleEndedIterator, FusedIterator, Iterator, TrustedLen};
use crate::ops::Try;
use crate::ops::TryWhereOutputEquals;
/// An iterator that links two iterators together, in a chain.
///
@ -98,7 +98,7 @@ fn try_fold<Acc, F, R>(&mut self, mut acc: Acc, mut f: F) -> R
where
Self: Sized,
F: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
if let Some(ref mut a) = self.a {
acc = a.try_fold(acc, &mut f)?;
@ -281,7 +281,7 @@ fn try_rfold<Acc, F, R>(&mut self, mut acc: Acc, mut f: F) -> R
where
Self: Sized,
F: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
if let Some(ref mut b) = self.b {
acc = b.try_rfold(acc, &mut f)?;

6
library/core/src/iter/adapters/cloned.rs
View File

@ -1,6 +1,6 @@
use crate::iter::adapters::{zip::try_get_unchecked, TrustedRandomAccess};
use crate::iter::{FusedIterator, TrustedLen};
use crate::ops::Try;
use crate::ops::TryWhereOutputEquals;
/// An iterator that clones the elements of an underlying iterator.
///
@ -46,7 +46,7 @@ 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>,
R: TryWhereOutputEquals<B>,
{
self.it.try_fold(init, clone_try_fold(f))
}
@ -82,7 +82,7 @@ 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>,
R: TryWhereOutputEquals<B>,
{
self.it.try_rfold(init, clone_try_fold(f))
}

6
library/core/src/iter/adapters/copied.rs
View File

@ -1,6 +1,6 @@
use crate::iter::adapters::{zip::try_get_unchecked, TrustedRandomAccess};
use crate::iter::{FusedIterator, TrustedLen};
use crate::ops::Try;
use crate::ops::TryWhereOutputEquals;
/// An iterator that copies the elements of an underlying iterator.
///
@ -50,7 +50,7 @@ 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>,
R: TryWhereOutputEquals<B>,
{
self.it.try_fold(init, copy_try_fold(f))
}
@ -98,7 +98,7 @@ 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>,
R: TryWhereOutputEquals<B>,
{
self.it.try_rfold(init, copy_try_fold(f))
}

4
library/core/src/iter/adapters/cycle.rs
View File

@ -1,4 +1,4 @@
use crate::{iter::FusedIterator, ops::Try};
use crate::{iter::FusedIterator, ops::TryWhereOutputEquals};
/// An iterator that repeats endlessly.
///
@ -53,7 +53,7 @@ fn size_hint(&self) -> (usize, Option<usize>) {
fn try_fold<Acc, F, R>(&mut self, mut acc: Acc, mut f: F) -> R
where
F: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
// fully iterate the current iterator. this is necessary because
// `self.iter` may be empty even when `self.orig` isn't

6
library/core/src/iter/adapters/enumerate.rs
View File

@ -1,6 +1,6 @@
use crate::iter::adapters::{zip::try_get_unchecked, SourceIter, TrustedRandomAccess};
use crate::iter::{FusedIterator, InPlaceIterable, TrustedLen};
use crate::ops::Try;
use crate::ops::TryWhereOutputEquals;
/// An iterator that yields the current count and the element during iteration.
///
@ -71,7 +71,7 @@ fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
#[inline]
fn enumerate<'a, T, Acc, R>(
@ -150,7 +150,7 @@ fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
// Can safely add and subtract the count, as `ExactSizeIterator` promises
// that the number of elements fits into a `usize`.

8
library/core/src/iter/adapters/filter.rs
View File

@ -1,6 +1,6 @@
use crate::fmt;
use crate::iter::{adapters::SourceIter, FusedIterator, InPlaceIterable};
use crate::ops::Try;
use crate::ops::TryWhereOutputEquals;
/// An iterator that filters the elements of `iter` with `predicate`.
///
@ -37,7 +37,7 @@ fn filter_fold<T, Acc>(
move |acc, item| if predicate(&item) { fold(acc, item) } else { acc }
}
fn filter_try_fold<'a, T, Acc, R: Try<Ok = Acc>>(
fn filter_try_fold<'a, T, Acc, R: TryWhereOutputEquals<Acc>>(
predicate: &'a mut impl FnMut(&T) -> bool,
mut fold: impl FnMut(Acc, T) -> R + 'a,
) -> impl FnMut(Acc, T) -> R + 'a {
@ -88,7 +88,7 @@ fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
self.iter.try_fold(init, filter_try_fold(&mut self.predicate, fold))
}
@ -117,7 +117,7 @@ fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
self.iter.try_rfold(init, filter_try_fold(&mut self.predicate, fold))
}

8
library/core/src/iter/adapters/filter_map.rs
View File

@ -1,6 +1,6 @@
use crate::fmt;
use crate::iter::{adapters::SourceIter, FusedIterator, InPlaceIterable};
use crate::ops::{ControlFlow, Try};
use crate::ops::{ControlFlow, TryWhereOutputEquals};
/// An iterator that uses `f` to both filter and map elements from `iter`.
///
@ -39,7 +39,7 @@ fn filter_map_fold<T, B, Acc>(
}
}
fn filter_map_try_fold<'a, T, B, Acc, R: Try<Ok = Acc>>(
fn filter_map_try_fold<'a, T, B, Acc, R: TryWhereOutputEquals<Acc>>(
f: &'a mut impl FnMut(T) -> Option<B>,
mut fold: impl FnMut(Acc, B) -> R + 'a,
) -> impl FnMut(Acc, T) -> R + 'a {
@ -72,7 +72,7 @@ fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
self.iter.try_fold(init, filter_map_try_fold(&mut self.f, fold))
}
@ -111,7 +111,7 @@ fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
self.iter.try_rfold(init, filter_map_try_fold(&mut self.f, fold))
}

18
library/core/src/iter/adapters/flatten.rs
View File

@ -1,6 +1,6 @@
use crate::fmt;
use crate::iter::{DoubleEndedIterator, Fuse, FusedIterator, Iterator, Map};
use crate::ops::Try;
use crate::ops::TryWhereOutputEquals;
/// An iterator that maps each element to an iterator, and yields the elements
/// of the produced iterators.
@ -61,7 +61,7 @@ fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
self.inner.try_fold(init, fold)
}
@ -91,7 +91,7 @@ fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
self.inner.try_rfold(init, fold)
}
@ -178,7 +178,7 @@ fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
self.inner.try_fold(init, fold)
}
@ -208,7 +208,7 @@ fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
self.inner.try_rfold(init, fold)
}
@ -293,10 +293,10 @@ fn try_fold<Acc, Fold, R>(&mut self, mut init: Acc, mut fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
#[inline]
fn flatten<'a, T: IntoIterator, Acc, R: Try<Ok = Acc>>(
fn flatten<'a, T: IntoIterator, Acc, R: TryWhereOutputEquals<Acc>>(
frontiter: &'a mut Option<T::IntoIter>,
fold: &'a mut impl FnMut(Acc, T::Item) -> R,
) -> impl FnMut(Acc, T) -> R + 'a {
@ -382,10 +382,10 @@ fn try_rfold<Acc, Fold, R>(&mut self, mut init: Acc, mut fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
#[inline]
fn flatten<'a, T: IntoIterator, Acc, R: Try<Ok = Acc>>(
fn flatten<'a, T: IntoIterator, Acc, R: TryWhereOutputEquals<Acc>>(
backiter: &'a mut Option<T::IntoIter>,
fold: &'a mut impl FnMut(Acc, T::Item) -> R,
) -> impl FnMut(Acc, T) -> R + 'a

18
library/core/src/iter/adapters/fuse.rs
View File

@ -3,7 +3,7 @@
use crate::iter::{
DoubleEndedIterator, ExactSizeIterator, FusedIterator, TrustedLen, TrustedRandomAccess,
};
use crate::ops::Try;
use crate::ops::TryWhereOutputEquals;
/// An iterator that yields `None` forever after the underlying iterator
/// yields `None` once.
@ -92,7 +92,7 @@ fn try_fold<Acc, Fold, R>(&mut self, acc: Acc, fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
FuseImpl::try_fold(self, acc, fold)
}
@ -148,7 +148,7 @@ fn try_rfold<Acc, Fold, R>(&mut self, acc: Acc, fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
FuseImpl::try_rfold(self, acc, fold)
}
@ -219,7 +219,7 @@ fn try_fold<Acc, Fold, R>(&mut self, acc: Acc, fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>;
R: TryWhereOutputEquals<Acc>;
fn fold<Acc, Fold>(self, acc: Acc, fold: Fold) -> Acc
where
Fold: FnMut(Acc, Self::Item) -> Acc;
@ -238,7 +238,7 @@ fn try_rfold<Acc, Fold, R>(&mut self, acc: Acc, fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
I: DoubleEndedIterator;
fn rfold<Acc, Fold>(self, acc: Acc, fold: Fold) -> Acc
where
@ -305,7 +305,7 @@ impl<I> FuseImpl<I> for Fuse<I>
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
if let Some(ref mut iter) = self.iter {
acc = iter.try_fold(acc, fold)?;
@ -354,7 +354,7 @@ impl<I> FuseImpl<I> for Fuse<I>
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
I: DoubleEndedIterator,
{
if let Some(ref mut iter) = self.iter {
@ -443,7 +443,7 @@ fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
unchecked!(self).try_fold(init, fold)
}
@ -485,7 +485,7 @@ fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
I: DoubleEndedIterator,
{
unchecked!(self).try_rfold(init, fold)

6
library/core/src/iter/adapters/inspect.rs
View File

@ -1,6 +1,6 @@
use crate::fmt;
use crate::iter::{adapters::SourceIter, FusedIterator, InPlaceIterable};
use crate::ops::Try;
use crate::ops::TryWhereOutputEquals;
/// An iterator that calls a function with a reference to each element before
/// yielding it.
@ -87,7 +87,7 @@ fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
self.iter.try_fold(init, inspect_try_fold(&mut self.f, fold))
}
@ -117,7 +117,7 @@ fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
self.iter.try_rfold(init, inspect_try_fold(&mut self.f, fold))
}

6
library/core/src/iter/adapters/map.rs
View File

@ -1,7 +1,7 @@
use crate::fmt;
use crate::iter::adapters::{zip::try_get_unchecked, SourceIter, TrustedRandomAccess};
use crate::iter::{FusedIterator, InPlaceIterable, TrustedLen};
use crate::ops::Try;
use crate::ops::TryWhereOutputEquals;
/// An iterator that maps the values of `iter` with `f`.
///
@ -110,7 +110,7 @@ fn try_fold<Acc, G, R>(&mut self, init: Acc, g: G) -> R
where
Self: Sized,
G: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
self.iter.try_fold(init, map_try_fold(&mut self.f, g))
}
@ -146,7 +146,7 @@ fn try_rfold<Acc, G, R>(&mut self, init: Acc, g: G) -> R
where
Self: Sized,
G: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
self.iter.try_rfold(init, map_try_fold(&mut self.f, g))
}

4
library/core/src/iter/adapters/map_while.rs
View File

@ -1,6 +1,6 @@
use crate::fmt;
use crate::iter::{adapters::SourceIter, InPlaceIterable};
use crate::ops::{ControlFlow, Try};
use crate::ops::{ControlFlow, TryWhereOutputEquals};
/// An iterator that only accepts elements while `predicate` returns `Some(_)`.
///
@ -54,7 +54,7 @@ fn try_fold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
let Self { iter, predicate } = self;
iter.try_fold(init, |acc, x| match predicate(x) {

4
library/core/src/iter/adapters/mod.rs
View File

@ -1,5 +1,5 @@
use crate::iter::{InPlaceIterable, Iterator};
use crate::ops::{ControlFlow, Try};
use crate::ops::{ControlFlow, TryWhereOutputEquals};
mod chain;
mod cloned;
@ -167,7 +167,7 @@ fn size_hint(&self) -> (usize, Option<usize>) {
fn try_fold<B, F, R>(&mut self, init: B, mut f: F) -> R
where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
R: TryWhereOutputEquals<B>,
{
let error = &mut *self.error;
self.iter

8
library/core/src/iter/adapters/peekable.rs
View File

@ -1,5 +1,5 @@
use crate::iter::{adapters::SourceIter, FusedIterator, InPlaceIterable, TrustedLen};
use crate::ops::Try;
use crate::ops::TryWhereOutputEquals;
/// An iterator with a `peek()` that returns an optional reference to the next
/// element.
@ -91,7 +91,7 @@ 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>,
R: TryWhereOutputEquals<B>,
{
let acc = match self.peeked.take() {
Some(None) => return try { init },
@ -134,7 +134,7 @@ 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>,
R: TryWhereOutputEquals<B>,
{
match self.peeked.take() {
Some(None) => try { init },
@ -142,7 +142,7 @@ fn try_rfold<B, F, R>(&mut self, init: B, mut f: F) -> R
Ok(acc) => f(acc, v),
Err(e) => {
self.peeked = Some(Some(v));
Try::from_error(e)
R::from_error(e)
}
},
None => self.iter.try_rfold(init, f),

6
library/core/src/iter/adapters/rev.rs
View File

@ -1,5 +1,5 @@
use crate::iter::{FusedIterator, TrustedLen};
use crate::ops::Try;
use crate::ops::TryWhereOutputEquals;
/// A double-ended iterator with the direction inverted.
///
@ -51,7 +51,7 @@ 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>,
R: TryWhereOutputEquals<B>,
{
self.iter.try_rfold(init, f)
}
@ -96,7 +96,7 @@ 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>,
R: TryWhereOutputEquals<B>,
{
self.iter.try_fold(init, f)
}

6
library/core/src/iter/adapters/scan.rs
View File

@ -1,6 +1,6 @@
use crate::fmt;
use crate::iter::{adapters::SourceIter, InPlaceIterable};
use crate::ops::{ControlFlow, Try};
use crate::ops::{ControlFlow, TryWhereOutputEquals};
/// An iterator to maintain state while iterating another iterator.
///
@ -56,9 +56,9 @@ fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
fn scan<'a, T, St, B, Acc, R: Try<Ok = Acc>>(
fn scan<'a, T, St, B, Acc, R: TryWhereOutputEquals<Acc>>(
state: &'a mut St,
f: &'a mut impl FnMut(&mut St, T) -> Option<B>,
mut fold: impl FnMut(Acc, B) -> R + 'a,

8
library/core/src/iter/adapters/skip.rs
View File

@ -1,6 +1,6 @@
use crate::intrinsics::unlikely;
use crate::iter::{adapters::SourceIter, FusedIterator, InPlaceIterable};
use crate::ops::{ControlFlow, Try};
use crate::ops::{ControlFlow, TryWhereOutputEquals};
/// An iterator that skips over `n` elements of `iter`.
///
@ -88,7 +88,7 @@ fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
let n = self.n;
self.n = 0;
@ -146,9 +146,9 @@ fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
fn check<T, Acc, R: Try<Ok = Acc>>(
fn check<T, Acc, R: TryWhereOutputEquals<Acc>>(
mut n: usize,
mut fold: impl FnMut(Acc, T) -> R,
) -> impl FnMut(Acc, T) -> ControlFlow<R, Acc> {

4
library/core/src/iter/adapters/skip_while.rs
View File

@ -1,6 +1,6 @@
use crate::fmt;
use crate::iter::{adapters::SourceIter, FusedIterator, InPlaceIterable};
use crate::ops::Try;
use crate::ops::TryWhereOutputEquals;
/// An iterator that rejects elements while `predicate` returns `true`.
///
@ -70,7 +70,7 @@ fn try_fold<Acc, Fold, R>(&mut self, mut init: Acc, mut fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
if !self.flag {
match self.next() {

6
library/core/src/iter/adapters/step_by.rs
View File

@ -1,4 +1,4 @@
use crate::{intrinsics, iter::from_fn, ops::Try};
use crate::{intrinsics, iter::from_fn, ops::TryWhereOutputEquals};
/// An iterator for stepping iterators by a custom amount.
///
@ -111,7 +111,7 @@ fn nth(&mut self, mut n: usize) -> Option<Self::Item> {
fn try_fold<Acc, F, R>(&mut self, mut acc: Acc, mut f: F) -> R
where
F: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
#[inline]
fn nth<I: Iterator>(iter: &mut I, step: usize) -> impl FnMut() -> Option<I::Item> + '_ {
@ -187,7 +187,7 @@ fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
fn try_rfold<Acc, F, R>(&mut self, init: Acc, mut f: F) -> R
where
F: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
#[inline]
fn nth_back<I: DoubleEndedIterator>(

8
library/core/src/iter/adapters/take.rs
View File

@ -3,7 +3,7 @@
adapters::zip::try_get_unchecked, adapters::SourceIter, FusedIterator, InPlaceIterable,
TrustedLen, TrustedRandomAccess,
};
use crate::ops::{ControlFlow, Try};
use crate::ops::{ControlFlow, TryWhereOutputEquals};
/// An iterator that only iterates over the first `n` iterations of `iter`.
///
@ -80,9 +80,9 @@ fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
fn check<'a, T, Acc, R: Try<Ok = Acc>>(
fn check<'a, T, Acc, R: TryWhereOutputEquals<Acc>>(
n: &'a mut usize,
mut fold: impl FnMut(Acc, T) -> R + 'a,
) -> impl FnMut(Acc, T) -> ControlFlow<R, Acc> + 'a {
@ -178,7 +178,7 @@ fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
if self.n == 0 {
try { init }

6
library/core/src/iter/adapters/take_while.rs
View File

@ -1,6 +1,6 @@
use crate::fmt;
use crate::iter::{adapters::SourceIter, FusedIterator, InPlaceIterable};
use crate::ops::{ControlFlow, Try};
use crate::ops::{ControlFlow, TryWhereOutputEquals};
/// An iterator that only accepts elements while `predicate` returns `true`.
///
@ -68,9 +68,9 @@ fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
R: TryWhereOutputEquals<Acc>,
{
fn check<'a, T, Acc, R: Try<Ok = Acc>>(
fn check<'a, T, Acc, R: TryWhereOutputEquals<Acc>>(
flag: &'a mut bool,
p: &'a mut impl FnMut(&T) -> bool,
mut fold: impl FnMut(Acc, T) -> R + 'a,

6
library/core/src/iter/range.rs
View File

@ -1,7 +1,7 @@
use crate::char;
use crate::convert::TryFrom;
use crate::mem;
use crate::ops::{self, Try};
use crate::ops::{self, TryWhereOutputEquals};
use super::{FusedIterator, TrustedLen, TrustedRandomAccess};
@ -755,7 +755,7 @@ 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>,
R: TryWhereOutputEquals<B>,
{
if self.is_empty() {
return try { init };
@ -860,7 +860,7 @@ 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>,
R: TryWhereOutputEquals<B>,
{
if self.is_empty() {
return try { init };

4
library/core/src/iter/traits/double_ended.rs
View File

@ -1,4 +1,4 @@
use crate::ops::{ControlFlow, Try};
use crate::ops::{ControlFlow, TryWhereOutputEquals};
/// An iterator able to yield elements from both ends.
///
@ -218,7 +218,7 @@ 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>,
R: TryWhereOutputEquals<B>,
{
let mut accum = init;
while let Some(x) = self.next_back() {

10
library/core/src/iter/traits/iterator.rs
View File

@ -3,7 +3,7 @@
// can't split that into multiple files.
use crate::cmp::{self, Ordering};
use crate::ops::{ControlFlow, Try};
use crate::ops::{ControlFlow, TryWhereOutputEquals};
use super::super::TrustedRandomAccess;
use super::super::{Chain, Cloned, Copied, Cycle, Enumerate, Filter, FilterMap, Fuse};
@ -1999,7 +1999,7 @@ 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>,
R: TryWhereOutputEquals<B>,
{
let mut accum = init;
while let Some(x) = self.next() {
@ -2041,7 +2041,7 @@ fn try_for_each<F, R>(&mut self, f: F) -> R
where
Self: Sized,
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
R: TryWhereOutputEquals<()>,
{
#[inline]
fn call<T, R>(mut f: impl FnMut(T) -> R) -> impl FnMut((), T) -> R {
@ -2416,13 +2416,13 @@ fn try_find<F, R>(&mut self, f: F) -> Result<Option<Self::Item>, R::Error>
where
Self: Sized,
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool>,
R: TryWhereOutputEquals<bool>,
{
#[inline]
fn check<F, T, R>(mut f: F) -> impl FnMut((), T) -> ControlFlow<Result<T, R::Error>>
where
F: FnMut(&T) -> R,
R: Try<Ok = bool>,
R: TryWhereOutputEquals<bool>,
{
move |(), x| match f(&x).into_result() {
Ok(false) => ControlFlow::CONTINUE,

13
library/core/src/ops/control_flow.rs
View File

@ -1,5 +1,4 @@
use crate::convert;
use crate::ops::{self, Try};
use crate::{convert, ops};
/// Used to tell an operation whether it should exit early or go on as usual.
///
@ -62,7 +61,7 @@ pub enum ControlFlow<B, C = ()> {
}
#[unstable(feature = "control_flow_enum", reason = "new API", issue = "75744")]
impl<B, C> Try for ControlFlow<B, C> {
impl<B, C> ops::TryV1 for ControlFlow<B, C> {
type Ok = C;
type Error = B;
#[inline]
@ -182,14 +181,14 @@ pub fn map_break<T, F>(self, f: F) -> ControlFlow<T, C>
}
}
impl<R: Try> ControlFlow<R, R::Ok> {
impl<R: ops::TryV1> ControlFlow<R, R::Ok> {
/// Create a `ControlFlow` from any type implementing `Try`.
#[unstable(feature = "control_flow_enum", reason = "new API", issue = "75744")]
#[inline]
pub fn from_try(r: R) -> Self {
match Try::into_result(r) {
match R::into_result(r) {
Ok(v) => ControlFlow::Continue(v),
Err(v) => ControlFlow::Break(Try::from_error(v)),
Err(v) => ControlFlow::Break(R::from_error(v)),
}
}
@ -198,7 +197,7 @@ pub fn from_try(r: R) -> Self {
#[inline]
pub fn into_try(self) -> R {
match self {
ControlFlow::Continue(v) => Try::from_ok(v),
ControlFlow::Continue(v) => R::from_ok(v),
ControlFlow::Break(v) => v,
}
}

19
library/core/src/ops/mod.rs
View File

@ -185,6 +185,9 @@
#[unstable(feature = "try_trait", issue = "42327")]
pub use self::r#try::Try;
#[unstable(feature = "try_trait_transition", reason = "for bootstrap", issue = "none")]
pub use self::r#try::Try as TryV1;
#[unstable(feature = "try_trait_v2", issue = "84277")]
pub use self::try_trait::FromResidual;
@ -202,3 +205,19 @@
#[unstable(feature = "control_flow_enum", reason = "new API", issue = "75744")]
pub use self::control_flow::ControlFlow;
/// [`TryV1`] and [`TryV2`] have different associated type names,
/// so rather than need `bootstrap` checks all over the library,
/// centralize the difference to this one trait alias.
///
/// As with all `try_trait_transition` stuff, this will be deleted
/// after the bootstrap compiler uses V2 for `?`.
///
/// ```
/// #![feature(try_trait_transition)]
/// use std::ops::TryWhereOutputEquals;
/// fn foo<T, C>() where T: TryWhereOutputEquals<C> {}
/// foo::<Option<i32>, i32>();
/// ```
#[unstable(feature = "try_trait_transition", reason = "for bootstrap", issue = "none")]
pub trait TryWhereOutputEquals<T> = TryV1<Ok = T>;

2
library/core/src/option.rs
View File

@ -1644,7 +1644,7 @@ fn from_iter<I: IntoIterator<Item = Option<A>>>(iter: I) -> Option<V> {
pub struct NoneError;
#[unstable(feature = "try_trait", issue = "42327")]
impl<T> ops::Try for Option<T> {
impl<T> ops::TryV1 for Option<T> {
type Ok = T;
type Error = NoneError;

2
library/core/src/result.rs
View File

@ -1627,7 +1627,7 @@ fn from_iter<I: IntoIterator<Item = Result<A, E>>>(iter: I) -> Result<V, E> {
}
#[unstable(feature = "try_trait", issue = "42327")]
impl<T, E> ops::Try for Result<T, E> {
impl<T, E> ops::TryV1 for Result<T, E> {
type Ok = T;
type Error = E;

2
library/core/src/slice/ascii.rs
View File

@ -110,7 +110,7 @@ fn size_hint(&self) -> (usize, Option<usize>) {
fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
where
Fold: FnMut(Acc, Self::Item) -> R,
R: ops::Try<Ok = Acc>,
R: ops::TryWhereOutputEquals<Acc>,
{
self.inner.try_fold(init, fold)
}

4
library/core/src/str/iter.rs
View File

@ -5,7 +5,7 @@
use crate::iter::TrustedRandomAccess;
use crate::iter::{Chain, FlatMap, Flatten};
use crate::iter::{Copied, Filter, FusedIterator, Map, TrustedLen};
use crate::ops::Try;
use crate::ops::TryWhereOutputEquals;
use crate::option;
use crate::slice::{self, Split as SliceSplit};
@ -1467,7 +1467,7 @@ fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
#[inline]
fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where
Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: TryWhereOutputEquals<Acc>
{
self.inner.try_fold(init, fold)
}

6
library/core/src/task/poll.rs
View File

@ -1,7 +1,7 @@
#![stable(feature = "futures_api", since = "1.36.0")]
use crate::convert;
use crate::ops::{self, ControlFlow, Try};
use crate::ops::{self, ControlFlow};
use crate::result::Result;
/// Indicates whether a value is available or if the current task has been
@ -129,7 +129,7 @@ fn from(t: T) -> Poll<T> {
}
#[stable(feature = "futures_api", since = "1.36.0")]
impl<T, E> Try for Poll<Result<T, E>> {
impl<T, E> ops::TryV1 for Poll<Result<T, E>> {
type Ok = Poll<T>;
type Error = E;
@ -184,7 +184,7 @@ fn from_residual(x: Result<convert::Infallible, E>) -> Self {
}
#[stable(feature = "futures_api", since = "1.36.0")]
impl<T, E> Try for Poll<Option<Result<T, E>>> {
impl<T, E> ops::TryV1 for Poll<Option<Result<T, E>>> {
type Ok = Poll<Option<T>>;
type Error = E;