pub struct JoinHandle<T> { /* private fields */ }
Expand description
An owned permission to join on a task (await its termination).
This can be thought of as the equivalent of std::thread::JoinHandle
for
a task rather than a thread.
A JoinHandle
detaches the associated task when it is dropped, which
means that there is no longer any handle to the task, and no way to join
on it.
This struct
is created by the task::spawn
and task::spawn_blocking
functions.
Examples
Creation from task::spawn
:
use tokio::task;
let join_handle: task::JoinHandle<_> = task::spawn(async {
// some work here
});
Creation from task::spawn_blocking
:
use tokio::task;
let join_handle: task::JoinHandle<_> = task::spawn_blocking(|| {
// some blocking work here
});
The generic parameter T
in JoinHandle<T>
is the return type of the spawned task.
If the return value is an i32, the join handle has type JoinHandle<i32>
:
use tokio::task;
let join_handle: task::JoinHandle<i32> = task::spawn(async {
5 + 3
});
If the task does not have a return value, the join handle has type JoinHandle<()>
:
use tokio::task;
let join_handle: task::JoinHandle<()> = task::spawn(async {
println!("I return nothing.");
});
Note that handle.await
doesn’t give you the return type directly. It is wrapped in a
Result
because panics in the spawned task are caught by Tokio. The ?
operator has
to be double chained to extract the returned value:
use tokio::task;
use std::io;
#[tokio::main]
async fn main() -> io::Result<()> {
let join_handle: task::JoinHandle<Result<i32, io::Error>> = tokio::spawn(async {
Ok(5 + 3)
});
let result = join_handle.await??;
assert_eq!(result, 8);
Ok(())
}
If the task panics, the error is a JoinError
that contains the panic:
use tokio::task;
use std::io;
use std::panic;
#[tokio::main]
async fn main() -> io::Result<()> {
let join_handle: task::JoinHandle<Result<i32, io::Error>> = tokio::spawn(async {
panic!("boom");
});
let err = join_handle.await.unwrap_err();
assert!(err.is_panic());
Ok(())
}
Child being detached and outliving its parent:
use tokio::task;
use tokio::time;
use std::time::Duration;
let original_task = task::spawn(async {
let _detached_task = task::spawn(async {
// Here we sleep to make sure that the first task returns before.
time::sleep(Duration::from_millis(10)).await;
// This will be called, even though the JoinHandle is dropped.
println!("♫ Still alive ♫");
});
});
original_task.await.expect("The task being joined has panicked");
println!("Original task is joined.");
// We make sure that the new task has time to run, before the main
// task returns.
time::sleep(Duration::from_millis(1000)).await;
Implementations
impl<T> JoinHandle<T>
impl<T> JoinHandle<T>
pub fn abort(&self)
pub fn abort(&self)
Abort the task associated with the handle.
Awaiting a cancelled task might complete as usual if the task was
already completed at the time it was cancelled, but most likely it
will fail with a cancelled JoinError
.
use tokio::time;
#[tokio::main]
async fn main() {
let mut handles = Vec::new();
handles.push(tokio::spawn(async {
time::sleep(time::Duration::from_secs(10)).await;
true
}));
handles.push(tokio::spawn(async {
time::sleep(time::Duration::from_secs(10)).await;
false
}));
for handle in &handles {
handle.abort();
}
for handle in handles {
assert!(handle.await.unwrap_err().is_cancelled());
}
}
Trait Implementations
impl<T> Debug for JoinHandle<T> where
T: Debug,
impl<T> Debug for JoinHandle<T> where
T: Debug,
impl<T> Drop for JoinHandle<T>
impl<T> Drop for JoinHandle<T>
impl<T> Future for JoinHandle<T>
impl<T> Future for JoinHandle<T>
fn poll(
self: Pin<&mut JoinHandle<T>>,
cx: &mut Context<'_>
) -> Poll<<JoinHandle<T> as Future>::Output>
fn poll(
self: Pin<&mut JoinHandle<T>>,
cx: &mut Context<'_>
) -> Poll<<JoinHandle<T> as Future>::Output>
Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available. Read more
impl<T> RefUnwindSafe for JoinHandle<T>
impl<T> Send for JoinHandle<T> where
T: Send,
impl<T> Sync for JoinHandle<T> where
T: Send,
impl<T> Unpin for JoinHandle<T>
impl<T> UnwindSafe for JoinHandle<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.
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,
Flattens the execution of this future when the successful result of this
future is a [Sink
]. Read more
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>;
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