Struct lair_keystore::dependencies::hc_seed_bundle::dependencies::futures::prelude::stream::Abortable
[−]pub struct Abortable<T> { /* private fields */ }
Expand description
A future/stream which can be remotely short-circuited using an AbortHandle
.
Implementations
impl<T> Abortable<T>
impl<T> Abortable<T>
pub fn new(task: T, reg: AbortRegistration) -> Abortable<T>ⓘNotable traits for Abortable<Fut>impl<Fut> Future for Abortable<Fut> where
Fut: Future, type Output = Result<<Fut as Future>::Output, Aborted>;
pub fn new(task: T, reg: AbortRegistration) -> Abortable<T>ⓘNotable traits for Abortable<Fut>impl<Fut> Future for Abortable<Fut> where
Fut: Future, type Output = Result<<Fut as Future>::Output, Aborted>;
Fut: Future, type Output = Result<<Fut as Future>::Output, Aborted>;
Creates a new Abortable
future/stream using an existing AbortRegistration
.
AbortRegistration
s can be acquired through AbortHandle::new
.
When abort
is called on the handle tied to reg
or if abort
has
already been called, the future/stream will complete immediately without making
any further progress.
Examples:
Usage with futures:
use futures::future::{Abortable, AbortHandle, Aborted};
let (abort_handle, abort_registration) = AbortHandle::new_pair();
let future = Abortable::new(async { 2 }, abort_registration);
abort_handle.abort();
assert_eq!(future.await, Err(Aborted));
Usage with streams:
let (abort_handle, abort_registration) = AbortHandle::new_pair();
let mut stream = Abortable::new(stream::iter(vec![1, 2, 3]), abort_registration);
abort_handle.abort();
assert_eq!(stream.next().await, None);
pub fn is_aborted(&self) -> bool
pub fn is_aborted(&self) -> bool
Checks whether the task has been aborted. Note that all this
method indicates is whether AbortHandle::abort
was called.
This means that it will return true
even if:
abort
was called after the task had completed.abort
was called while the task was being polled - the task may still be running and will not be stopped untilpoll
returns.
Trait Implementations
impl<T> Clone for Abortable<T> where
T: Clone,
impl<T> Clone for Abortable<T> where
T: Clone,
fn clone(&self) -> Abortable<T>ⓘNotable traits for Abortable<Fut>impl<Fut> Future for Abortable<Fut> where
Fut: Future, type Output = Result<<Fut as Future>::Output, Aborted>;
fn clone(&self) -> Abortable<T>ⓘNotable traits for Abortable<Fut>impl<Fut> Future for Abortable<Fut> where
Fut: Future, type Output = Result<<Fut as Future>::Output, Aborted>;
Fut: Future, type Output = Result<<Fut as Future>::Output, Aborted>;
Returns a copy of the value. Read more
1.0.0 · sourcefn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
impl<St> Stream for Abortable<St> where
St: Stream,
impl<St> Stream for Abortable<St> where
St: Stream,
impl<'__pin, T> Unpin for Abortable<T> where
__Origin<'__pin, T>: Unpin,
Auto Trait Implementations
impl<T> !RefUnwindSafe for Abortable<T>
impl<T> Send for Abortable<T> where
T: Send,
impl<T> Sync for Abortable<T> where
T: Sync,
impl<T> !UnwindSafe for Abortable<T>
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
impl<T> FutureExt for T where
T: Future + ?Sized,
impl<T> FutureExt for T where
T: Future + ?Sized,
fn map<U, F>(self, f: F) -> Map<Self, F>ⓘNotable traits for Map<Fut, F>impl<Fut, F> Future for Map<Fut, F> where
Map<Fut, F>: Future, type Output = <Map<Fut, F> as Future>::Output;
where
F: FnOnce(Self::Output) -> U,
fn map<U, F>(self, f: F) -> Map<Self, F>ⓘNotable traits for Map<Fut, F>impl<Fut, F> Future for Map<Fut, F> where
Map<Fut, F>: Future, type Output = <Map<Fut, F> as Future>::Output;
where
F: FnOnce(Self::Output) -> U,
Map<Fut, F>: Future, type Output = <Map<Fut, F> as Future>::Output;
Map this future’s output to a different type, returning a new future of the resulting type. Read more
fn map_into<U>(self) -> MapInto<Self, U>ⓘNotable traits for MapInto<Fut, T>impl<Fut, T> Future for MapInto<Fut, T> where
Map<Fut, IntoFn<T>>: Future, type Output = <Map<Fut, IntoFn<T>> as Future>::Output;
where
Self::Output: Into<U>,
fn map_into<U>(self) -> MapInto<Self, U>ⓘNotable traits for MapInto<Fut, T>impl<Fut, T> Future for MapInto<Fut, T> where
Map<Fut, IntoFn<T>>: Future, type Output = <Map<Fut, IntoFn<T>> as Future>::Output;
where
Self::Output: Into<U>,
Map<Fut, IntoFn<T>>: Future, type Output = <Map<Fut, IntoFn<T>> as Future>::Output;
Map this future’s output to a different type, returning a new future of the resulting type. Read more
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>ⓘNotable traits for Then<Fut1, Fut2, F>impl<Fut1, Fut2, F> Future for Then<Fut1, Fut2, F> where
Flatten<Map<Fut1, F>, Fut2>: Future, type Output = <Flatten<Map<Fut1, F>, Fut2> as Future>::Output;
where
F: FnOnce(Self::Output) -> Fut,
Fut: Future,
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>ⓘNotable traits for Then<Fut1, Fut2, F>impl<Fut1, Fut2, F> Future for Then<Fut1, Fut2, F> where
Flatten<Map<Fut1, F>, Fut2>: Future, type Output = <Flatten<Map<Fut1, F>, Fut2> as Future>::Output;
where
F: FnOnce(Self::Output) -> Fut,
Fut: Future,
Flatten<Map<Fut1, F>, Fut2>: Future, type Output = <Flatten<Map<Fut1, F>, Fut2> as Future>::Output;
Chain on a computation for when a future finished, passing the result of
the future to the provided closure f
. Read more
fn left_future<B>(self) -> Either<Self, B>ⓘNotable traits for Either<A, B>impl<A, B> Future for Either<A, B> where
A: Future,
B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output;
where
B: Future<Output = Self::Output>,
fn left_future<B>(self) -> Either<Self, B>ⓘNotable traits for Either<A, B>impl<A, B> Future for Either<A, B> where
A: Future,
B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output;
where
B: Future<Output = Self::Output>,
A: Future,
B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output;
Wrap this future in an Either
future, making it the left-hand variant
of that Either
. Read more
fn right_future<A>(self) -> Either<A, Self>ⓘNotable traits for Either<A, B>impl<A, B> Future for Either<A, B> where
A: Future,
B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output;
where
A: Future<Output = Self::Output>,
fn right_future<A>(self) -> Either<A, Self>ⓘNotable traits for Either<A, B>impl<A, B> Future for Either<A, B> where
A: Future,
B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output;
where
A: Future<Output = Self::Output>,
A: Future,
B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output;
Wrap this future in an Either
future, making it the right-hand variant
of that Either
. Read more
fn into_stream(self) -> IntoStream<Self>
fn into_stream(self) -> IntoStream<Self>
Convert this future into a single element stream. Read more
fn flatten(self) -> Flatten<Self>ⓘNotable traits for Flatten<F>impl<F> Future for Flatten<F> where
F: Future,
Flatten<F, <F as Future>::Output>: Future, type Output = <Flatten<F, <F as Future>::Output> as Future>::Output;
where
Self::Output: Future,
fn flatten(self) -> Flatten<Self>ⓘNotable traits for Flatten<F>impl<F> Future for Flatten<F> where
F: Future,
Flatten<F, <F as Future>::Output>: Future, type Output = <Flatten<F, <F as Future>::Output> as Future>::Output;
where
Self::Output: Future,
F: Future,
Flatten<F, <F as Future>::Output>: Future, type Output = <Flatten<F, <F as Future>::Output> as Future>::Output;
Flatten the execution of this future when the output of this future is itself another future. Read more
fn flatten_stream(self) -> FlattenStream<Self> where
Self::Output: Stream,
fn flatten_stream(self) -> FlattenStream<Self> where
Self::Output: Stream,
Flatten the execution of this future when the successful result of this future is a stream. Read more
fn fuse(self) -> Fuse<Self>ⓘNotable traits for Fuse<Fut>impl<Fut> Future for Fuse<Fut> where
Fut: Future, type Output = <Fut as Future>::Output;
fn fuse(self) -> Fuse<Self>ⓘNotable traits for Fuse<Fut>impl<Fut> Future for Fuse<Fut> where
Fut: Future, type Output = <Fut as Future>::Output;
Fut: Future, type Output = <Fut as Future>::Output;
Fuse a future such that poll
will never again be called once it has
completed. This method can be used to turn any Future
into a
FusedFuture
. Read more
fn inspect<F>(self, f: F) -> Inspect<Self, F>ⓘNotable traits for Inspect<Fut, F>impl<Fut, F> Future for Inspect<Fut, F> where
Map<Fut, InspectFn<F>>: Future, type Output = <Map<Fut, InspectFn<F>> as Future>::Output;
where
F: FnOnce(&Self::Output),
fn inspect<F>(self, f: F) -> Inspect<Self, F>ⓘNotable traits for Inspect<Fut, F>impl<Fut, F> Future for Inspect<Fut, F> where
Map<Fut, InspectFn<F>>: Future, type Output = <Map<Fut, InspectFn<F>> as Future>::Output;
where
F: FnOnce(&Self::Output),
Map<Fut, InspectFn<F>>: Future, type Output = <Map<Fut, InspectFn<F>> as Future>::Output;
Do something with the output of a future before passing it on. Read more
fn catch_unwind(self) -> CatchUnwind<Self>ⓘNotable traits for CatchUnwind<Fut>impl<Fut> Future for CatchUnwind<Fut> where
Fut: Future + UnwindSafe, type Output = Result<<Fut as Future>::Output, Box<dyn Any + Send + 'static, Global>>;
where
Self: UnwindSafe,
fn catch_unwind(self) -> CatchUnwind<Self>ⓘNotable traits for CatchUnwind<Fut>impl<Fut> Future for CatchUnwind<Fut> where
Fut: Future + UnwindSafe, type Output = Result<<Fut as Future>::Output, Box<dyn Any + Send + 'static, Global>>;
where
Self: UnwindSafe,
Fut: Future + UnwindSafe, type Output = Result<<Fut as Future>::Output, Box<dyn Any + Send + 'static, Global>>;
Catches unwinding panics while polling the future. Read more
Create a cloneable handle to this future where all handles will resolve to the same result. Read more
fn remote_handle(self) -> (Remote<Self>, RemoteHandle<Self::Output>)
fn remote_handle(self) -> (Remote<Self>, RemoteHandle<Self::Output>)
Turn this future into a future that yields ()
on completion and sends
its output to another future on a separate task. Read more
fn boxed<'a>(
self
) -> Pin<Box<dyn Future<Output = Self::Output> + Send + 'a, Global>>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
where
Self: 'a + Send,
fn boxed<'a>(
self
) -> Pin<Box<dyn Future<Output = Self::Output> + Send + 'a, Global>>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
where
Self: 'a + Send,
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
Wrap the future in a Box, pinning it. Read more
fn boxed_local<'a>(
self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'a, Global>>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
where
Self: 'a,
fn boxed_local<'a>(
self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'a, Global>>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
where
Self: 'a,
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
Wrap the future in a Box, pinning it. Read more
fn unit_error(self) -> UnitError<Self>ⓘNotable traits for UnitError<Fut>impl<Fut> Future for UnitError<Fut> where
Map<Fut, OkFn<()>>: Future, type Output = <Map<Fut, OkFn<()>> as Future>::Output;
fn unit_error(self) -> UnitError<Self>ⓘNotable traits for UnitError<Fut>impl<Fut> Future for UnitError<Fut> where
Map<Fut, OkFn<()>>: Future, type Output = <Map<Fut, OkFn<()>> as Future>::Output;
Map<Fut, OkFn<()>>: Future, type Output = <Map<Fut, OkFn<()>> as Future>::Output;
Turns a Future<Output = T>
into a
TryFuture<Ok = T, Error = ()
>. Read more
fn never_error(self) -> NeverError<Self>ⓘNotable traits for NeverError<Fut>impl<Fut> Future for NeverError<Fut> where
Map<Fut, OkFn<Infallible>>: Future, type Output = <Map<Fut, OkFn<Infallible>> as Future>::Output;
fn never_error(self) -> NeverError<Self>ⓘNotable traits for NeverError<Fut>impl<Fut> Future for NeverError<Fut> where
Map<Fut, OkFn<Infallible>>: Future, type Output = <Map<Fut, OkFn<Infallible>> as Future>::Output;
Map<Fut, OkFn<Infallible>>: Future, type Output = <Map<Fut, OkFn<Infallible>> as Future>::Output;
Turns a Future<Output = T>
into a
TryFuture<Ok = T, Error = Never
>. Read more
fn poll_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Self::Output> where
Self: Unpin,
fn poll_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Self::Output> where
Self: Unpin,
A convenience for calling Future::poll
on Unpin
future types.
fn now_or_never(self) -> Option<Self::Output>
fn now_or_never(self) -> Option<Self::Output>
Evaluates and consumes the future, returning the resulting output if
the future is ready after the first call to Future::poll
. Read more
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
fn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
sourcefn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
fn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
sourceimpl<F> IntoFuture for F where
F: Future,
impl<F> IntoFuture for F where
F: Future,
type Output = <F as Future>::Output
type Output = <F as Future>::Output
into_future
)The output that the future will produce on completion.
type IntoFuture = F
type IntoFuture = F
into_future
)Which kind of future are we turning this into?
sourcefn into_future(self) -> <F as IntoFuture>::IntoFuture
fn into_future(self) -> <F as IntoFuture>::IntoFuture
into_future
)Creates a future from a value. Read more
impl<T> Pointable for T
impl<T> Pointable for T
impl<T> StreamExt for T where
T: Stream + ?Sized,
impl<T> StreamExt for T where
T: Stream + ?Sized,
fn next(&mut self) -> Next<'_, Self>ⓘNotable traits for Next<'_, St>impl<'_, St> Future for Next<'_, St> where
St: Stream + Unpin + ?Sized, type Output = Option<<St as Stream>::Item>;
where
Self: Unpin,
fn next(&mut self) -> Next<'_, Self>ⓘNotable traits for Next<'_, St>impl<'_, St> Future for Next<'_, St> where
St: Stream + Unpin + ?Sized, type Output = Option<<St as Stream>::Item>;
where
Self: Unpin,
St: Stream + Unpin + ?Sized, type Output = Option<<St as Stream>::Item>;
Creates a future that resolves to the next item in the stream. Read more
fn into_future(self) -> StreamFuture<Self>ⓘNotable traits for StreamFuture<St>impl<St> Future for StreamFuture<St> where
St: Stream + Unpin, type Output = (Option<<St as Stream>::Item>, St);
where
Self: Unpin,
fn into_future(self) -> StreamFuture<Self>ⓘNotable traits for StreamFuture<St>impl<St> Future for StreamFuture<St> where
St: Stream + Unpin, type Output = (Option<<St as Stream>::Item>, St);
where
Self: Unpin,
St: Stream + Unpin, type Output = (Option<<St as Stream>::Item>, St);
fn map<T, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> T,
fn map<T, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> T,
Maps this stream’s items to a different type, returning a new stream of the resulting type. Read more
fn enumerate(self) -> Enumerate<Self>
fn enumerate(self) -> Enumerate<Self>
Creates a stream which gives the current iteration count as well as the next value. Read more
fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
Filters the values produced by this stream according to the provided asynchronous predicate. Read more
fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = Option<T>>,
fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = Option<T>>,
Filters the values produced by this stream while simultaneously mapping them to a different type according to the provided asynchronous closure. Read more
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future,
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future,
Computes from this stream’s items new items of a different type using an asynchronous closure. Read more
fn collect<C>(self) -> Collect<Self, C>ⓘNotable traits for Collect<St, C>impl<St, C> Future for Collect<St, C> where
St: Stream,
C: Default + Extend<<St as Stream>::Item>, type Output = C;
where
C: Default + Extend<Self::Item>,
fn collect<C>(self) -> Collect<Self, C>ⓘNotable traits for Collect<St, C>impl<St, C> Future for Collect<St, C> where
St: Stream,
C: Default + Extend<<St as Stream>::Item>, type Output = C;
where
C: Default + Extend<Self::Item>,
St: Stream,
C: Default + Extend<<St as Stream>::Item>, type Output = C;
Transforms a stream into a collection, returning a future representing the result of that computation. Read more
fn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB>ⓘNotable traits for Unzip<St, FromA, FromB>impl<St, A, B, FromA, FromB> Future for Unzip<St, FromA, FromB> where
St: Stream<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>, type Output = (FromA, FromB);
where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Stream<Item = (A, B)>,
fn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB>ⓘNotable traits for Unzip<St, FromA, FromB>impl<St, A, B, FromA, FromB> Future for Unzip<St, FromA, FromB> where
St: Stream<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>, type Output = (FromA, FromB);
where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Stream<Item = (A, B)>,
St: Stream<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>, type Output = (FromA, FromB);
Converts a stream of pairs into a future, which resolves to pair of containers. Read more
fn concat(self) -> Concat<Self>ⓘNotable traits for Concat<St>impl<St> Future for Concat<St> where
St: Stream,
<St as Stream>::Item: Extend<<<St as Stream>::Item as IntoIterator>::Item>,
<St as Stream>::Item: IntoIterator,
<St as Stream>::Item: Default, type Output = <St as Stream>::Item;
where
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
fn concat(self) -> Concat<Self>ⓘNotable traits for Concat<St>impl<St> Future for Concat<St> where
St: Stream,
<St as Stream>::Item: Extend<<<St as Stream>::Item as IntoIterator>::Item>,
<St as Stream>::Item: IntoIterator,
<St as Stream>::Item: Default, type Output = <St as Stream>::Item;
where
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
St: Stream,
<St as Stream>::Item: Extend<<<St as Stream>::Item as IntoIterator>::Item>,
<St as Stream>::Item: IntoIterator,
<St as Stream>::Item: Default, type Output = <St as Stream>::Item;
Concatenate all items of a stream into a single extendable destination, returning a future representing the end result. Read more
fn count(self) -> Count<Self>
fn count(self) -> Count<Self>
Drives the stream to completion, counting the number of items. Read more
fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F>ⓘNotable traits for Fold<St, Fut, T, F>impl<St, Fut, T, F> Future for Fold<St, Fut, T, F> where
St: Stream,
F: FnMut(T, <St as Stream>::Item) -> Fut,
Fut: Future<Output = T>, type Output = T;
where
F: FnMut(T, Self::Item) -> Fut,
Fut: Future<Output = T>,
fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F>ⓘNotable traits for Fold<St, Fut, T, F>impl<St, Fut, T, F> Future for Fold<St, Fut, T, F> where
St: Stream,
F: FnMut(T, <St as Stream>::Item) -> Fut,
Fut: Future<Output = T>, type Output = T;
where
F: FnMut(T, Self::Item) -> Fut,
Fut: Future<Output = T>,
St: Stream,
F: FnMut(T, <St as Stream>::Item) -> Fut,
Fut: Future<Output = T>, type Output = T;
Execute an accumulating asynchronous computation over a stream, collecting all the values into one final result. Read more
fn any<Fut, F>(self, f: F) -> Any<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn any<Fut, F>(self, f: F) -> Any<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = bool>,
Execute predicate over asynchronous stream, and return true
if any element in stream satisfied a predicate. Read more
fn all<Fut, F>(self, f: F) -> All<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn all<Fut, F>(self, f: F) -> All<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = bool>,
Execute predicate over asynchronous stream, and return true
if all element in stream satisfied a predicate. Read more
fn flatten(self) -> Flatten<Self> where
Self::Item: Stream,
fn flatten(self) -> Flatten<Self> where
Self::Item: Stream,
Flattens a stream of streams into just one continuous stream. Read more
fn flatten_unordered(
self,
limit: impl Into<Option<usize>>
) -> FlattenUnordered<Self> where
Self::Item: Stream,
Self::Item: Unpin,
fn flatten_unordered(
self,
limit: impl Into<Option<usize>>
) -> FlattenUnordered<Self> where
Self::Item: Stream,
Self::Item: Unpin,
Flattens a stream of streams into just one continuous stream. Polls inner streams concurrently. Read more
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: Stream,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: Stream,
Maps a stream like StreamExt::map
but flattens nested Stream
s. Read more
fn flat_map_unordered<U, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> FlatMapUnordered<Self, U, F> where
U: Stream + Unpin,
F: FnMut(Self::Item) -> U,
fn flat_map_unordered<U, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> FlatMapUnordered<Self, U, F> where
U: Stream + Unpin,
F: FnMut(Self::Item) -> U,
Maps a stream like StreamExt::map
but flattens nested Stream
s
and polls them concurrently, yielding items in any order, as they made
available. Read more
fn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F> where
F: FnMut(&mut S, Self::Item) -> Fut,
Fut: Future<Output = Option<B>>,
fn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F> where
F: FnMut(&mut S, Self::Item) -> Fut,
Fut: Future<Output = Option<B>>,
Combinator similar to StreamExt::fold
that holds internal state
and produces a new stream. Read more
fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
Skip elements on this stream while the provided asynchronous predicate
resolves to true
. Read more
fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
Take elements from this stream while the provided asynchronous predicate
resolves to true
. Read more
fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut> where
Fut: Future,
fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut> where
Fut: Future,
Take elements from this stream until the provided future resolves. Read more
fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F>ⓘNotable traits for ForEach<St, Fut, F>impl<St, Fut, F> Future for ForEach<St, Fut, F> where
St: Stream,
F: FnMut(<St as Stream>::Item) -> Fut,
Fut: Future<Output = ()>, type Output = ();
where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F>ⓘNotable traits for ForEach<St, Fut, F>impl<St, Fut, F> Future for ForEach<St, Fut, F> where
St: Stream,
F: FnMut(<St as Stream>::Item) -> Fut,
Fut: Future<Output = ()>, type Output = ();
where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
St: Stream,
F: FnMut(<St as Stream>::Item) -> Fut,
Fut: Future<Output = ()>, type Output = ();
Runs this stream to completion, executing the provided asynchronous closure for each element on the stream. Read more
fn for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> ForEachConcurrent<Self, Fut, F>ⓘNotable traits for ForEachConcurrent<St, Fut, F>impl<St, Fut, F> Future for ForEachConcurrent<St, Fut, F> where
St: Stream,
F: FnMut(<St as Stream>::Item) -> Fut,
Fut: Future<Output = ()>, type Output = ();
where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
fn for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> ForEachConcurrent<Self, Fut, F>ⓘNotable traits for ForEachConcurrent<St, Fut, F>impl<St, Fut, F> Future for ForEachConcurrent<St, Fut, F> where
St: Stream,
F: FnMut(<St as Stream>::Item) -> Fut,
Fut: Future<Output = ()>, type Output = ();
where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
St: Stream,
F: FnMut(<St as Stream>::Item) -> Fut,
Fut: Future<Output = ()>, type Output = ();
Runs this stream to completion, executing the provided asynchronous closure for each element on the stream concurrently as elements become available. Read more
fn take(self, n: usize) -> Take<Self>
fn take(self, n: usize) -> Take<Self>
Creates a new stream of at most n
items of the underlying stream. Read more
fn skip(self, n: usize) -> Skip<Self>
fn skip(self, n: usize) -> Skip<Self>
Creates a new stream which skips n
items of the underlying stream. Read more
fn catch_unwind(self) -> CatchUnwind<Self> where
Self: UnwindSafe,
fn catch_unwind(self) -> CatchUnwind<Self> where
Self: UnwindSafe,
Catches unwinding panics while polling the stream. Read more
fn boxed<'a>(
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + Send + 'a, Global>>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
where
Self: 'a + Send,
fn boxed<'a>(
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + Send + 'a, Global>>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
where
Self: 'a + Send,
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
Wrap the stream in a Box, pinning it. Read more
fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a, Global>>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
where
Self: 'a,
fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a, Global>>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
where
Self: 'a,
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
Wrap the stream in a Box, pinning it. Read more
fn buffered(self, n: usize) -> Buffered<Self> where
Self::Item: Future,
fn buffered(self, n: usize) -> Buffered<Self> where
Self::Item: Future,
An adaptor for creating a buffered list of pending futures. Read more
fn buffer_unordered(self, n: usize) -> BufferUnordered<Self> where
Self::Item: Future,
fn buffer_unordered(self, n: usize) -> BufferUnordered<Self> where
Self::Item: Future,
An adaptor for creating a buffered list of pending futures (unordered). Read more
fn zip<St>(self, other: St) -> Zip<Self, St> where
St: Stream,
fn zip<St>(self, other: St) -> Zip<Self, St> where
St: Stream,
An adapter for zipping two streams together. Read more
fn chain<St>(self, other: St) -> Chain<Self, St> where
St: Stream<Item = Self::Item>,
fn chain<St>(self, other: St) -> Chain<Self, St> where
St: Stream<Item = Self::Item>,
Adapter for chaining two streams. Read more
fn chunks(self, capacity: usize) -> Chunks<Self>
fn chunks(self, capacity: usize) -> Chunks<Self>
An adaptor for chunking up items of the stream inside a vector. Read more
fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>
fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>
An adaptor for chunking up ready items of the stream inside a vector. Read more
fn forward<S>(self, sink: S) -> Forward<Self, S>ⓘNotable traits for Forward<St, Si>impl<St, Si> Future for Forward<St, Si> where
St: TryStream,
Forward<St, Si, <St as TryStream>::Ok>: Future, type Output = <Forward<St, Si, <St as TryStream>::Ok> as Future>::Output;
where
S: Sink<Self::Ok, Error = Self::Error>,
Self: TryStream,
fn forward<S>(self, sink: S) -> Forward<Self, S>ⓘNotable traits for Forward<St, Si>impl<St, Si> Future for Forward<St, Si> where
St: TryStream,
Forward<St, Si, <St as TryStream>::Ok>: Future, type Output = <Forward<St, Si, <St as TryStream>::Ok> as Future>::Output;
where
S: Sink<Self::Ok, Error = Self::Error>,
Self: TryStream,
St: TryStream,
Forward<St, Si, <St as TryStream>::Ok>: Future, type Output = <Forward<St, Si, <St as TryStream>::Ok> as Future>::Output;
A future that completes after the given stream has been fully processed into the sink and the sink has been flushed and closed. Read more
fn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>) where
Self: Sink<Item>,
fn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>) where
Self: Sink<Item>,
Splits this Stream + Sink
object into separate Sink
and Stream
objects. Read more
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
Do something with each item of this stream, afterwards passing it on. Read more
fn left_stream<B>(self) -> Either<Self, B>ⓘNotable traits for Either<A, B>impl<A, B> Future for Either<A, B> where
A: Future,
B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output;
where
B: Stream<Item = Self::Item>,
fn left_stream<B>(self) -> Either<Self, B>ⓘNotable traits for Either<A, B>impl<A, B> Future for Either<A, B> where
A: Future,
B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output;
where
B: Stream<Item = Self::Item>,
A: Future,
B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output;
Wrap this stream in an Either
stream, making it the left-hand variant
of that Either
. Read more
fn right_stream<B>(self) -> Either<B, Self>ⓘNotable traits for Either<A, B>impl<A, B> Future for Either<A, B> where
A: Future,
B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output;
where
B: Stream<Item = Self::Item>,
fn right_stream<B>(self) -> Either<B, Self>ⓘNotable traits for Either<A, B>impl<A, B> Future for Either<A, B> where
A: Future,
B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output;
where
B: Stream<Item = Self::Item>,
A: Future,
B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output;
Wrap this stream in an Either
stream, making it the right-hand variant
of that Either
. Read more
fn poll_next_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> where
Self: Unpin,
fn poll_next_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> where
Self: Unpin,
A convenience method for calling Stream::poll_next
on Unpin
stream types. Read more
fn select_next_some(&mut self) -> SelectNextSome<'_, Self>ⓘNotable traits for SelectNextSome<'_, St>impl<'_, St> Future for SelectNextSome<'_, St> where
St: FusedStream + Unpin + ?Sized, type Output = <St as Stream>::Item;
where
Self: Unpin + FusedStream,
fn select_next_some(&mut self) -> SelectNextSome<'_, Self>ⓘNotable traits for SelectNextSome<'_, St>impl<'_, St> Future for SelectNextSome<'_, St> where
St: FusedStream + Unpin + ?Sized, type Output = <St as Stream>::Item;
where
Self: Unpin + FusedStream,
St: FusedStream + Unpin + ?Sized, type Output = <St as Stream>::Item;
impl<Fut> TryFutureExt for Fut where
Fut: TryFuture + ?Sized,
impl<Fut> TryFutureExt for Fut where
Fut: TryFuture + ?Sized,
fn flatten_sink<Item>(self) -> FlattenSink<Self, Self::Ok> where
Self::Ok: Sink<Item>,
<Self::Ok as Sink<Item>>::Error == Self::Error,
fn flatten_sink<Item>(self) -> FlattenSink<Self, Self::Ok> where
Self::Ok: Sink<Item>,
<Self::Ok as Sink<Item>>::Error == Self::Error,
fn map_ok<T, F>(self, f: F) -> MapOk<Self, F>ⓘNotable traits for MapOk<Fut, F>impl<Fut, F> Future for MapOk<Fut, F> where
Map<IntoFuture<Fut>, MapOkFn<F>>: Future, type Output = <Map<IntoFuture<Fut>, MapOkFn<F>> as Future>::Output;
where
F: FnOnce(Self::Ok) -> T,
fn map_ok<T, F>(self, f: F) -> MapOk<Self, F>ⓘNotable traits for MapOk<Fut, F>impl<Fut, F> Future for MapOk<Fut, F> where
Map<IntoFuture<Fut>, MapOkFn<F>>: Future, type Output = <Map<IntoFuture<Fut>, MapOkFn<F>> as Future>::Output;
where
F: FnOnce(Self::Ok) -> T,
Map<IntoFuture<Fut>, MapOkFn<F>>: Future, type Output = <Map<IntoFuture<Fut>, MapOkFn<F>> as Future>::Output;
Maps this future’s success value to a different value. Read more
fn map_ok_or_else<T, E, F>(self, e: E, f: F) -> MapOkOrElse<Self, F, E>ⓘNotable traits for MapOkOrElse<Fut, F, G>impl<Fut, F, G> Future for MapOkOrElse<Fut, F, G> where
Map<IntoFuture<Fut>, ChainFn<MapOkFn<F>, ChainFn<MapErrFn<G>, MergeResultFn>>>: Future, type Output = <Map<IntoFuture<Fut>, ChainFn<MapOkFn<F>, ChainFn<MapErrFn<G>, MergeResultFn>>> as Future>::Output;
where
F: FnOnce(Self::Ok) -> T,
E: FnOnce(Self::Error) -> T,
fn map_ok_or_else<T, E, F>(self, e: E, f: F) -> MapOkOrElse<Self, F, E>ⓘNotable traits for MapOkOrElse<Fut, F, G>impl<Fut, F, G> Future for MapOkOrElse<Fut, F, G> where
Map<IntoFuture<Fut>, ChainFn<MapOkFn<F>, ChainFn<MapErrFn<G>, MergeResultFn>>>: Future, type Output = <Map<IntoFuture<Fut>, ChainFn<MapOkFn<F>, ChainFn<MapErrFn<G>, MergeResultFn>>> as Future>::Output;
where
F: FnOnce(Self::Ok) -> T,
E: FnOnce(Self::Error) -> T,
Map<IntoFuture<Fut>, ChainFn<MapOkFn<F>, ChainFn<MapErrFn<G>, MergeResultFn>>>: Future, type Output = <Map<IntoFuture<Fut>, ChainFn<MapOkFn<F>, ChainFn<MapErrFn<G>, MergeResultFn>>> as Future>::Output;
Maps this future’s success value to a different value, and permits for error handling resulting in the same type. Read more
fn map_err<E, F>(self, f: F) -> MapErr<Self, F>ⓘNotable traits for MapErr<Fut, F>impl<Fut, F> Future for MapErr<Fut, F> where
Map<IntoFuture<Fut>, MapErrFn<F>>: Future, type Output = <Map<IntoFuture<Fut>, MapErrFn<F>> as Future>::Output;
where
F: FnOnce(Self::Error) -> E,
fn map_err<E, F>(self, f: F) -> MapErr<Self, F>ⓘNotable traits for MapErr<Fut, F>impl<Fut, F> Future for MapErr<Fut, F> where
Map<IntoFuture<Fut>, MapErrFn<F>>: Future, type Output = <Map<IntoFuture<Fut>, MapErrFn<F>> as Future>::Output;
where
F: FnOnce(Self::Error) -> E,
Map<IntoFuture<Fut>, MapErrFn<F>>: Future, type Output = <Map<IntoFuture<Fut>, MapErrFn<F>> as Future>::Output;
Maps this future’s error value to a different value. Read more
fn err_into<E>(self) -> ErrInto<Self, E>ⓘNotable traits for ErrInto<Fut, E>impl<Fut, E> Future for ErrInto<Fut, E> where
MapErr<Fut, IntoFn<E>>: Future, type Output = <MapErr<Fut, IntoFn<E>> as Future>::Output;
where
Self::Error: Into<E>,
fn err_into<E>(self) -> ErrInto<Self, E>ⓘNotable traits for ErrInto<Fut, E>impl<Fut, E> Future for ErrInto<Fut, E> where
MapErr<Fut, IntoFn<E>>: Future, type Output = <MapErr<Fut, IntoFn<E>> as Future>::Output;
where
Self::Error: Into<E>,
MapErr<Fut, IntoFn<E>>: Future, type Output = <MapErr<Fut, IntoFn<E>> as Future>::Output;
fn ok_into<U>(self) -> OkInto<Self, U>ⓘNotable traits for OkInto<Fut, E>impl<Fut, E> Future for OkInto<Fut, E> where
MapOk<Fut, IntoFn<E>>: Future, type Output = <MapOk<Fut, IntoFn<E>> as Future>::Output;
where
Self::Ok: Into<U>,
fn ok_into<U>(self) -> OkInto<Self, U>ⓘNotable traits for OkInto<Fut, E>impl<Fut, E> Future for OkInto<Fut, E> where
MapOk<Fut, IntoFn<E>>: Future, type Output = <MapOk<Fut, IntoFn<E>> as Future>::Output;
where
Self::Ok: Into<U>,
MapOk<Fut, IntoFn<E>>: Future, type Output = <MapOk<Fut, IntoFn<E>> as Future>::Output;
fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F>ⓘNotable traits for AndThen<Fut1, Fut2, F>impl<Fut1, Fut2, F> Future for AndThen<Fut1, Fut2, F> where
TryFlatten<MapOk<Fut1, F>, Fut2>: Future, type Output = <TryFlatten<MapOk<Fut1, F>, Fut2> as Future>::Output;
where
F: FnOnce(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F>ⓘNotable traits for AndThen<Fut1, Fut2, F>impl<Fut1, Fut2, F> Future for AndThen<Fut1, Fut2, F> where
TryFlatten<MapOk<Fut1, F>, Fut2>: Future, type Output = <TryFlatten<MapOk<Fut1, F>, Fut2> as Future>::Output;
where
F: FnOnce(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
TryFlatten<MapOk<Fut1, F>, Fut2>: Future, type Output = <TryFlatten<MapOk<Fut1, F>, Fut2> as Future>::Output;
Executes another future after this one resolves successfully. The success value is passed to a closure to create this subsequent future. Read more
fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F>ⓘNotable traits for OrElse<Fut1, Fut2, F>impl<Fut1, Fut2, F> Future for OrElse<Fut1, Fut2, F> where
TryFlattenErr<MapErr<Fut1, F>, Fut2>: Future, type Output = <TryFlattenErr<MapErr<Fut1, F>, Fut2> as Future>::Output;
where
F: FnOnce(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F>ⓘNotable traits for OrElse<Fut1, Fut2, F>impl<Fut1, Fut2, F> Future for OrElse<Fut1, Fut2, F> where
TryFlattenErr<MapErr<Fut1, F>, Fut2>: Future, type Output = <TryFlattenErr<MapErr<Fut1, F>, Fut2> as Future>::Output;
where
F: FnOnce(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
TryFlattenErr<MapErr<Fut1, F>, Fut2>: Future, type Output = <TryFlattenErr<MapErr<Fut1, F>, Fut2> as Future>::Output;
Executes another future if this one resolves to an error. The error value is passed to a closure to create this subsequent future. Read more
fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F>ⓘNotable traits for InspectOk<Fut, F>impl<Fut, F> Future for InspectOk<Fut, F> where
Inspect<IntoFuture<Fut>, InspectOkFn<F>>: Future, type Output = <Inspect<IntoFuture<Fut>, InspectOkFn<F>> as Future>::Output;
where
F: FnOnce(&Self::Ok),
fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F>ⓘNotable traits for InspectOk<Fut, F>impl<Fut, F> Future for InspectOk<Fut, F> where
Inspect<IntoFuture<Fut>, InspectOkFn<F>>: Future, type Output = <Inspect<IntoFuture<Fut>, InspectOkFn<F>> as Future>::Output;
where
F: FnOnce(&Self::Ok),
Inspect<IntoFuture<Fut>, InspectOkFn<F>>: Future, type Output = <Inspect<IntoFuture<Fut>, InspectOkFn<F>> as Future>::Output;
Do something with the success value of a future before passing it on. Read more
fn inspect_err<F>(self, f: F) -> InspectErr<Self, F>ⓘNotable traits for InspectErr<Fut, F>impl<Fut, F> Future for InspectErr<Fut, F> where
Inspect<IntoFuture<Fut>, InspectErrFn<F>>: Future, type Output = <Inspect<IntoFuture<Fut>, InspectErrFn<F>> as Future>::Output;
where
F: FnOnce(&Self::Error),
fn inspect_err<F>(self, f: F) -> InspectErr<Self, F>ⓘNotable traits for InspectErr<Fut, F>impl<Fut, F> Future for InspectErr<Fut, F> where
Inspect<IntoFuture<Fut>, InspectErrFn<F>>: Future, type Output = <Inspect<IntoFuture<Fut>, InspectErrFn<F>> as Future>::Output;
where
F: FnOnce(&Self::Error),
Inspect<IntoFuture<Fut>, InspectErrFn<F>>: Future, type Output = <Inspect<IntoFuture<Fut>, InspectErrFn<F>> as Future>::Output;
Do something with the error value of a future before passing it on. Read more
fn try_flatten(self) -> TryFlatten<Self, Self::Ok>ⓘNotable traits for TryFlatten<Fut1, Fut2>impl<Fut1, Fut2> Future for TryFlatten<Fut1, Fut2> where
TryFlatten<Fut1, Fut2>: Future, type Output = <TryFlatten<Fut1, Fut2> as Future>::Output;
where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
fn try_flatten(self) -> TryFlatten<Self, Self::Ok>ⓘNotable traits for TryFlatten<Fut1, Fut2>impl<Fut1, Fut2> Future for TryFlatten<Fut1, Fut2> where
TryFlatten<Fut1, Fut2>: Future, type Output = <TryFlatten<Fut1, Fut2> as Future>::Output;
where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
TryFlatten<Fut1, Fut2>: Future, type Output = <TryFlatten<Fut1, Fut2> as Future>::Output;
Flatten the execution of this future when the successful result of this future is another future. Read more
fn try_flatten_stream(self) -> TryFlattenStream<Self> where
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error == Self::Error,
fn try_flatten_stream(self) -> TryFlattenStream<Self> where
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error == Self::Error,
Flatten the execution of this future when the successful result of this future is a stream. Read more
fn unwrap_or_else<F>(self, f: F) -> UnwrapOrElse<Self, F>ⓘNotable traits for UnwrapOrElse<Fut, F>impl<Fut, F> Future for UnwrapOrElse<Fut, F> where
Map<IntoFuture<Fut>, UnwrapOrElseFn<F>>: Future, type Output = <Map<IntoFuture<Fut>, UnwrapOrElseFn<F>> as Future>::Output;
where
F: FnOnce(Self::Error) -> Self::Ok,
fn unwrap_or_else<F>(self, f: F) -> UnwrapOrElse<Self, F>ⓘNotable traits for UnwrapOrElse<Fut, F>impl<Fut, F> Future for UnwrapOrElse<Fut, F> where
Map<IntoFuture<Fut>, UnwrapOrElseFn<F>>: Future, type Output = <Map<IntoFuture<Fut>, UnwrapOrElseFn<F>> as Future>::Output;
where
F: FnOnce(Self::Error) -> Self::Ok,
Map<IntoFuture<Fut>, UnwrapOrElseFn<F>>: Future, type Output = <Map<IntoFuture<Fut>, UnwrapOrElseFn<F>> as Future>::Output;
fn into_future(self) -> IntoFuture<Self>ⓘNotable traits for IntoFuture<Fut>impl<Fut> Future for IntoFuture<Fut> where
Fut: TryFuture, type Output = Result<<Fut as TryFuture>::Ok, <Fut as TryFuture>::Error>;
fn into_future(self) -> IntoFuture<Self>ⓘNotable traits for IntoFuture<Fut>impl<Fut> Future for IntoFuture<Fut> where
Fut: TryFuture, type Output = Result<<Fut as TryFuture>::Ok, <Fut as TryFuture>::Error>;
Fut: TryFuture, type Output = Result<<Fut as TryFuture>::Ok, <Fut as TryFuture>::Error>;
fn try_poll_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<Self::Ok, Self::Error>> where
Self: Unpin,
fn try_poll_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<Self::Ok, Self::Error>> where
Self: Unpin,
A convenience method for calling TryFuture::try_poll
on Unpin
future types. Read more
impl<S, T, E> TryStream for S where
S: Stream<Item = Result<T, E>> + ?Sized,
impl<S, T, E> TryStream for S where
S: Stream<Item = Result<T, E>> + ?Sized,
impl<S> TryStreamExt for S where
S: TryStream + ?Sized,
impl<S> TryStreamExt for S where
S: TryStream + ?Sized,
fn err_into<E>(self) -> ErrInto<Self, E> where
Self::Error: Into<E>,
fn err_into<E>(self) -> ErrInto<Self, E> where
Self::Error: Into<E>,
Wraps the current stream in a new stream which converts the error type into the one provided. Read more
fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> where
F: FnMut(Self::Ok) -> T,
fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> where
F: FnMut(Self::Ok) -> T,
Wraps the current stream in a new stream which maps the success value using the provided closure. Read more
fn map_err<E, F>(self, f: F) -> MapErr<Self, F> where
F: FnMut(Self::Error) -> E,
fn map_err<E, F>(self, f: F) -> MapErr<Self, F> where
F: FnMut(Self::Error) -> E,
Wraps the current stream in a new stream which maps the error value using the provided closure. Read more
fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
Chain on a computation for when a value is ready, passing the successful
results to the provided closure f
. Read more
fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where
F: FnMut(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where
F: FnMut(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
Chain on a computation for when an error happens, passing the
erroneous result to the provided closure f
. Read more
fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> where
F: FnMut(&Self::Ok),
fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> where
F: FnMut(&Self::Ok),
Do something with the success value of this stream, afterwards passing it on. Read more
fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where
F: FnMut(&Self::Error),
fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where
F: FnMut(&Self::Error),
Do something with the error value of this stream, afterwards passing it on. Read more
fn into_stream(self) -> IntoStream<Self>
fn into_stream(self) -> IntoStream<Self>
fn try_next(&mut self) -> TryNext<'_, Self>ⓘNotable traits for TryNext<'_, St>impl<'_, St> Future for TryNext<'_, St> where
St: TryStream + Unpin + ?Sized, type Output = Result<Option<<St as TryStream>::Ok>, <St as TryStream>::Error>;
where
Self: Unpin,
fn try_next(&mut self) -> TryNext<'_, Self>ⓘNotable traits for TryNext<'_, St>impl<'_, St> Future for TryNext<'_, St> where
St: TryStream + Unpin + ?Sized, type Output = Result<Option<<St as TryStream>::Ok>, <St as TryStream>::Error>;
where
Self: Unpin,
St: TryStream + Unpin + ?Sized, type Output = Result<Option<<St as TryStream>::Ok>, <St as TryStream>::Error>;
Creates a future that attempts to resolve the next item in the stream. If an error is encountered before the next item, the error is returned instead. Read more
fn try_for_each<Fut, F>(self, f: F) -> TryForEach<Self, Fut, F>ⓘNotable traits for TryForEach<St, Fut, F>impl<St, Fut, F> Future for TryForEach<St, Fut, F> where
St: TryStream,
F: FnMut(<St as TryStream>::Ok) -> Fut,
Fut: TryFuture<Ok = (), Error = <St as TryStream>::Error>, type Output = Result<(), <St as TryStream>::Error>;
where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = (), Error = Self::Error>,
fn try_for_each<Fut, F>(self, f: F) -> TryForEach<Self, Fut, F>ⓘNotable traits for TryForEach<St, Fut, F>impl<St, Fut, F> Future for TryForEach<St, Fut, F> where
St: TryStream,
F: FnMut(<St as TryStream>::Ok) -> Fut,
Fut: TryFuture<Ok = (), Error = <St as TryStream>::Error>, type Output = Result<(), <St as TryStream>::Error>;
where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = (), Error = Self::Error>,
St: TryStream,
F: FnMut(<St as TryStream>::Ok) -> Fut,
Fut: TryFuture<Ok = (), Error = <St as TryStream>::Error>, type Output = Result<(), <St as TryStream>::Error>;
Attempts to run this stream to completion, executing the provided asynchronous closure for each element on the stream. Read more
fn try_skip_while<Fut, F>(self, f: F) -> TrySkipWhile<Self, Fut, F> where
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
fn try_skip_while<Fut, F>(self, f: F) -> TrySkipWhile<Self, Fut, F> where
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
Skip elements on this stream while the provided asynchronous predicate
resolves to true
. Read more
fn try_take_while<Fut, F>(self, f: F) -> TryTakeWhile<Self, Fut, F> where
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
fn try_take_while<Fut, F>(self, f: F) -> TryTakeWhile<Self, Fut, F> where
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
Take elements on this stream while the provided asynchronous predicate
resolves to true
. Read more
fn try_for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> TryForEachConcurrent<Self, Fut, F>ⓘNotable traits for TryForEachConcurrent<St, Fut, F>impl<St, Fut, F> Future for TryForEachConcurrent<St, Fut, F> where
St: TryStream,
F: FnMut(<St as TryStream>::Ok) -> Fut,
Fut: Future<Output = Result<(), <St as TryStream>::Error>>, type Output = Result<(), <St as TryStream>::Error>;
where
F: FnMut(Self::Ok) -> Fut,
Fut: Future<Output = Result<(), Self::Error>>,
fn try_for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> TryForEachConcurrent<Self, Fut, F>ⓘNotable traits for TryForEachConcurrent<St, Fut, F>impl<St, Fut, F> Future for TryForEachConcurrent<St, Fut, F> where
St: TryStream,
F: FnMut(<St as TryStream>::Ok) -> Fut,
Fut: Future<Output = Result<(), <St as TryStream>::Error>>, type Output = Result<(), <St as TryStream>::Error>;
where
F: FnMut(Self::Ok) -> Fut,
Fut: Future<Output = Result<(), Self::Error>>,
St: TryStream,
F: FnMut(<St as TryStream>::Ok) -> Fut,
Fut: Future<Output = Result<(), <St as TryStream>::Error>>, type Output = Result<(), <St as TryStream>::Error>;
Attempts to run this stream to completion, executing the provided asynchronous closure for each element on the stream concurrently as elements become available, exiting as soon as an error occurs. Read more
fn try_collect<C>(self) -> TryCollect<Self, C>ⓘNotable traits for TryCollect<St, C>impl<St, C> Future for TryCollect<St, C> where
St: TryStream,
C: Default + Extend<<St as TryStream>::Ok>, type Output = Result<C, <St as TryStream>::Error>;
where
C: Default + Extend<Self::Ok>,
fn try_collect<C>(self) -> TryCollect<Self, C>ⓘNotable traits for TryCollect<St, C>impl<St, C> Future for TryCollect<St, C> where
St: TryStream,
C: Default + Extend<<St as TryStream>::Ok>, type Output = Result<C, <St as TryStream>::Error>;
where
C: Default + Extend<Self::Ok>,
St: TryStream,
C: Default + Extend<<St as TryStream>::Ok>, type Output = Result<C, <St as TryStream>::Error>;
Attempt to transform a stream into a collection, returning a future representing the result of that computation. Read more
fn try_chunks(self, capacity: usize) -> TryChunks<Self>
fn try_chunks(self, capacity: usize) -> TryChunks<Self>
An adaptor for chunking up successful items of the stream inside a vector. Read more
fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F> where
Fut: Future<Output = bool>,
F: FnMut(&Self::Ok) -> Fut,
fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F> where
Fut: Future<Output = bool>,
F: FnMut(&Self::Ok) -> Fut,
Attempt to filter the values produced by this stream according to the provided asynchronous closure. Read more
fn try_filter_map<Fut, F, T>(self, f: F) -> TryFilterMap<Self, Fut, F> where
Fut: TryFuture<Ok = Option<T>, Error = Self::Error>,
F: FnMut(Self::Ok) -> Fut,
fn try_filter_map<Fut, F, T>(self, f: F) -> TryFilterMap<Self, Fut, F> where
Fut: TryFuture<Ok = Option<T>, Error = Self::Error>,
F: FnMut(Self::Ok) -> Fut,
Attempt to filter the values produced by this stream while simultaneously mapping them to a different type according to the provided asynchronous closure. Read more
fn try_flatten(self) -> TryFlatten<Self> where
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error: From<Self::Error>,
fn try_flatten(self) -> TryFlatten<Self> where
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error: From<Self::Error>,
Flattens a stream of streams into just one continuous stream. Read more
fn try_fold<T, Fut, F>(self, init: T, f: F) -> TryFold<Self, Fut, T, F>ⓘNotable traits for TryFold<St, Fut, T, F>impl<St, Fut, T, F> Future for TryFold<St, Fut, T, F> where
St: TryStream,
F: FnMut(T, <St as TryStream>::Ok) -> Fut,
Fut: TryFuture<Ok = T, Error = <St as TryStream>::Error>, type Output = Result<T, <St as TryStream>::Error>;
where
F: FnMut(T, Self::Ok) -> Fut,
Fut: TryFuture<Ok = T, Error = Self::Error>,
fn try_fold<T, Fut, F>(self, init: T, f: F) -> TryFold<Self, Fut, T, F>ⓘNotable traits for TryFold<St, Fut, T, F>impl<St, Fut, T, F> Future for TryFold<St, Fut, T, F> where
St: TryStream,
F: FnMut(T, <St as TryStream>::Ok) -> Fut,
Fut: TryFuture<Ok = T, Error = <St as TryStream>::Error>, type Output = Result<T, <St as TryStream>::Error>;
where
F: FnMut(T, Self::Ok) -> Fut,
Fut: TryFuture<Ok = T, Error = Self::Error>,
St: TryStream,
F: FnMut(T, <St as TryStream>::Ok) -> Fut,
Fut: TryFuture<Ok = T, Error = <St as TryStream>::Error>, type Output = Result<T, <St as TryStream>::Error>;
Attempt to execute an accumulating asynchronous computation over a stream, collecting all the values into one final result. Read more
fn try_concat(self) -> TryConcat<Self>ⓘNotable traits for TryConcat<St>impl<St> Future for TryConcat<St> where
St: TryStream,
<St as TryStream>::Ok: Extend<<<St as TryStream>::Ok as IntoIterator>::Item>,
<St as TryStream>::Ok: IntoIterator,
<St as TryStream>::Ok: Default, type Output = Result<<St as TryStream>::Ok, <St as TryStream>::Error>;
where
Self::Ok: Extend<<Self::Ok as IntoIterator>::Item>,
Self::Ok: IntoIterator,
Self::Ok: Default,
fn try_concat(self) -> TryConcat<Self>ⓘNotable traits for TryConcat<St>impl<St> Future for TryConcat<St> where
St: TryStream,
<St as TryStream>::Ok: Extend<<<St as TryStream>::Ok as IntoIterator>::Item>,
<St as TryStream>::Ok: IntoIterator,
<St as TryStream>::Ok: Default, type Output = Result<<St as TryStream>::Ok, <St as TryStream>::Error>;
where
Self::Ok: Extend<<Self::Ok as IntoIterator>::Item>,
Self::Ok: IntoIterator,
Self::Ok: Default,
St: TryStream,
<St as TryStream>::Ok: Extend<<<St as TryStream>::Ok as IntoIterator>::Item>,
<St as TryStream>::Ok: IntoIterator,
<St as TryStream>::Ok: Default, type Output = Result<<St as TryStream>::Ok, <St as TryStream>::Error>;
Attempt to concatenate all items of a stream into a single extendable destination, returning a future representing the end result. Read more
fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
Attempt to execute several futures from a stream concurrently (unordered). Read more
fn try_buffered(self, n: usize) -> TryBuffered<Self> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
fn try_buffered(self, n: usize) -> TryBuffered<Self> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
Attempt to execute several futures from a stream concurrently. Read more
fn try_poll_next_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Option<Result<Self::Ok, Self::Error>>> where
Self: Unpin,
fn try_poll_next_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Option<Result<Self::Ok, Self::Error>>> where
Self: Unpin,
A convenience method for calling TryStream::try_poll_next
on Unpin
stream types. Read more
fn into_async_read(self) -> IntoAsyncRead<Self> where
Self: TryStreamExt<Error = Error> + Unpin,
Self::Ok: AsRef<[u8]>,
fn into_async_read(self) -> IntoAsyncRead<Self> where
Self: TryStreamExt<Error = Error> + Unpin,
Self::Ok: AsRef<[u8]>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
fn vzip(self) -> V
sourceimpl<T> WithSubscriber for T
impl<T> WithSubscriber for T
sourcefn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
where
S: Into<Dispatch>,
T: Future, type Output = <T as Future>::Output;
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
sourcefn with_current_subscriber(self) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
fn with_current_subscriber(self) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more