Trait futures::prelude::Future

pub trait Future {
    type Output;
    fn poll(self: PinMut<Self>, cx: &mut Context) -> Poll<Self::Output>;
}

🔬 This is a nightly-only experimental API. (futures_api)

futures in libcore are unstable

A future represents an asychronous computation.

A future is a value that may not have finished computing yet. This kind of "asynchronous value" makes it possible for a thread to continue doing useful work while it waits for the value to become available.

The poll method

The core method of future, poll, attempts to resolve the future into a final value. This method does not block if the value is not ready. Instead, the current task is scheduled to be woken up when it's possible to make further progress by polling again. The wake up is performed using cx.waker(), a handle for waking up the current task.

When using a future, you generally won't call poll directly, but instead await! the value.

Associated Types

type Output

🔬 This is a nightly-only experimental API. (futures_api)

futures in libcore are unstable

The result of the Future.

Required Methods

fn poll(self: PinMut<Self>, cx: &mut Context) -> Poll<Self::Output>

🔬 This is a nightly-only experimental API. (futures_api)

futures in libcore are unstable

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

Return value

This function returns:

• Poll::Pending if the future is not ready yet
• Poll::Ready(val) with the result val of this future if it finished successfully.

Once a future has finished, clients should not poll it again.

When a future is not ready yet, poll returns Poll::Pending. The future will also register the interest of the current task in the value being produced. For example, if the future represents the availability of data on a socket, then the task is recorded so that when data arrives, it is woken up (via cx.waker()). Once a task has been woken up, it should attempt to poll the future again, which may or may not produce a final value.

Note that if Pending is returned it only means that the current task (represented by the argument cx) will receive a notification. Tasks from previous calls to poll will not receive notifications.

Runtime characteristics

Futures alone are inert; they must be actively polled to make progress, meaning that each time the current task is woken up, it should actively re-poll pending futures that it still has an interest in.

The poll function is not called repeatedly in a tight loop for futures, but only whenever the future itself is ready, as signaled via the Waker inside task::Context. If you're familiar with the poll(2) or select(2) syscalls on Unix it's worth noting that futures typically do not suffer the same problems of "all wakeups must poll all events"; they are more like epoll(4).

An implementation of poll should strive to return quickly, and must never block. Returning quickly prevents unnecessarily clogging up threads or event loops. If it is known ahead of time that a call to poll may end up taking awhile, the work should be offloaded to a thread pool (or something similar) to ensure that poll can return quickly.

Panics

Once a future has completed (returned Ready from poll), then any future calls to poll may panic, block forever, or otherwise cause bad behavior. The Future trait itself provides no guarantees about the behavior of poll after a future has completed.

Implementations on Foreign Types

impl<'a, F> Future for &'a mut F where     F: Unpin + Future + ?Sized,

type Output = <F as Future>::Output

🔬 This is a nightly-only experimental API. (futures_api)

futures in libcore are unstable

fn poll(     self: PinMut<&'a mut F>,     cx: &mut Context ) -> Poll<<&'a mut F as Future>::Output>

🔬 This is a nightly-only experimental API. (futures_api)

futures in libcore are unstable

impl<'a, F> Future for PinMut<'a, F> where     F: Future + ?Sized,

type Output = <F as Future>::Output

🔬 This is a nightly-only experimental API. (futures_api)

futures in libcore are unstable

fn poll(     self: PinMut<PinMut<'a, F>>,     cx: &mut Context ) -> Poll<<PinMut<'a, F> as Future>::Output>

🔬 This is a nightly-only experimental API. (futures_api)

futures in libcore are unstable

impl<Fut, T> Future for UnitError<Fut> where     Fut: Future<Output = T>,

type Output = Result<T, ()>

🔬 This is a nightly-only experimental API. (futures_api)

futures in libcore are unstable

fn poll(self: PinMut<UnitError<Fut>>, cx: &mut Context) -> Poll<Result<T, ()>>

🔬 This is a nightly-only experimental API. (futures_api)

futures in libcore are unstable

impl<'a, T> Future for BiLockAcquire<'a, T>

type Output = BiLockGuard<'a, T>

🔬 This is a nightly-only experimental API. (futures_api)

futures in libcore are unstable

fn poll(     self: PinMut<BiLockAcquire<'a, T>>,     cx: &mut Context ) -> Poll<<BiLockAcquire<'a, T> as Future>::Output>

🔬 This is a nightly-only experimental API. (futures_api)

futures in libcore are unstable

impl<St, Fut, F> Future for ForEachConcurrent<St, Fut, F> where     F: FnMut(<St as Stream>::Item) -> Fut,     Fut: Future<Output = ()>,     St: Stream,

type Output = ()

🔬 This is a nightly-only experimental API. (futures_api)

futures in libcore are unstable

fn poll(     self: PinMut<ForEachConcurrent<St, Fut, F>>,     cx: &mut Context ) -> Poll<()>

🔬 This is a nightly-only experimental API. (futures_api)

futures in libcore are unstable

impl<St, Fut, F> Future for TryForEachConcurrent<St, Fut, F> where     F: FnMut(<St as TryStream>::Ok) -> Fut,     Fut: Future<Output = Result<(), <St as TryStream>::Error>>,     St: TryStream,

type Output = Result<(), <St as TryStream>::Error>

🔬 This is a nightly-only experimental API. (futures_api)

futures in libcore are unstable

fn poll(     self: PinMut<TryForEachConcurrent<St, Fut, F>>,     cx: &mut Context ) -> Poll<<TryForEachConcurrent<St, Fut, F> as Future>::Output>

🔬 This is a nightly-only experimental API. (futures_api)

futures in libcore are unstable

impl<'a, F> Future for AssertUnwindSafe<F> where     F: Future,

type Output = <F as Future>::Output

🔬 This is a nightly-only experimental API. (futures_api)

futures in libcore are unstable

fn poll(     self: PinMut<AssertUnwindSafe<F>>,     cx: &mut Context ) -> Poll<<AssertUnwindSafe<F> as Future>::Output>

🔬 This is a nightly-only experimental API. (futures_api)

futures in libcore are unstable

impl<F> Future for PinBox<F> where     F: Future + ?Sized,

type Output = <F as Future>::Output

🔬 This is a nightly-only experimental API. (futures_api)

futures in libcore are unstable

fn poll(     self: PinMut<PinBox<F>>,     cx: &mut Context ) -> Poll<<PinBox<F> as Future>::Output>

🔬 This is a nightly-only experimental API. (futures_api)

futures in libcore are unstable

impl<F> Future for Box<F> where     F: Unpin + Future + ?Sized,

type Output = <F as Future>::Output

🔬 This is a nightly-only experimental API. (futures_api)

futures in libcore are unstable

fn poll(     self: PinMut<Box<F>>,     cx: &mut Context ) -> Poll<<Box<F> as Future>::Output>

🔬 This is a nightly-only experimental API. (futures_api)

futures in libcore are unstable

Implementors

• impl<'a, T> Future for LocalFutureObj<'a, T> type Output = T;

• impl<'a, T> Future for FutureObj<'a, T> type Output = T;

• impl<T> Future for JoinHandle<T> where     T: 'static + Send,  type Output = T;

• impl<Fut> Future for Flatten<Fut> where     Fut: Future,     <Fut as Future>::Output: Future,  type Output = <<Fut as Future>::Output as Future>::Output;

• impl<'_, W> Future for futures::io::Flush<'_, W> where     W: AsyncWrite + ?Sized,  type Output = Result<(), Error>;

• impl<'_, W> Future for WriteAll<'_, W> where     W: AsyncWrite + ?Sized,  type Output = Result<(), Error>;

• impl<'_, A> Future for ReadToEnd<'_, A> where     A: AsyncRead + ?Sized,  type Output = Result<(), Error>;

• impl<'_, W> Future for futures::io::Close<'_, W> where     W: AsyncWrite + ?Sized,  type Output = Result<(), Error>;

• impl<Fut, F, T> Future for Map<Fut, F> where     F: FnOnce(<Fut as Future>::Output) -> T,     Fut: Future,  type Output = T;

• impl<Fut> Future for MaybeDone<Fut> where     Fut: Future,  type Output = ();

• impl<Fut1, Fut2, Fut3, Fut4, Fut5> Future for TryJoin5<Fut1, Fut2, Fut3, Fut4, Fut5> where     Fut1: TryFuture,     Fut2: TryFuture<Error = <Fut1 as TryFuture>::Error>,     Fut3: TryFuture<Error = <Fut1 as TryFuture>::Error>,     Fut4: TryFuture<Error = <Fut1 as TryFuture>::Error>,     Fut5: TryFuture<Error = <Fut1 as TryFuture>::Error>,  type Output = Result<(<Fut1 as TryFuture>::Ok, <Fut2 as TryFuture>::Ok, <Fut3 as TryFuture>::Ok, <Fut4 as TryFuture>::Ok, <Fut5 as TryFuture>::Ok), <Fut1 as TryFuture>::Error>;

• impl<T> Future for Ready<T> type Output = T;

• impl<Fut1, Fut2, F> Future for OrElse<Fut1, Fut2, F> where     F: FnOnce(<Fut1 as TryFuture>::Error) -> Fut2,     Fut1: TryFuture,     Fut2: TryFuture<Ok = <Fut1 as TryFuture>::Ok>,  type Output = Result<<Fut2 as TryFuture>::Ok, <Fut2 as TryFuture>::Error>;

• impl<'_, Si> Future for futures::sink::Flush<'_, Si> where     Si: Unpin + Sink + ?Sized,  type Output = Result<(), <Si as Sink>::SinkError>;

• impl<F> Future for OptionFuture<F> where     F: Future,  type Output = Option<<F as Future>::Output>;

• impl<Fut1, Fut2, Fut3> Future for TryJoin3<Fut1, Fut2, Fut3> where     Fut1: TryFuture,     Fut2: TryFuture<Error = <Fut1 as TryFuture>::Error>,     Fut3: TryFuture<Error = <Fut1 as TryFuture>::Error>,  type Output = Result<(<Fut1 as TryFuture>::Ok, <Fut2 as TryFuture>::Ok, <Fut3 as TryFuture>::Ok), <Fut1 as TryFuture>::Error>;

• impl<Fut1, Fut2, Fut3, Fut4> Future for Join4<Fut1, Fut2, Fut3, Fut4> where     Fut1: Future,     Fut2: Future,     Fut3: Future,     Fut4: Future,  type Output = (<Fut1 as Future>::Output, <Fut2 as Future>::Output, <Fut3 as Future>::Output, <Fut4 as Future>::Output);

• impl<R, F> Future for Lazy<F> where     F: FnOnce(&mut Context) -> R,  type Output = R;

• impl<Fut1, Fut2, Fut3> Future for Join3<Fut1, Fut2, Fut3> where     Fut1: Future,     Fut2: Future,     Fut3: Future,  type Output = (<Fut1 as Future>::Output, <Fut2 as Future>::Output, <Fut3 as Future>::Output);

• impl<Fut> Future for Fuse<Fut> where     Fut: Future,  type Output = <Fut as Future>::Output;

• impl<St, Si> Future for Forward<St, Si> where     Si: Sink + Unpin,     St: Stream<Item = Result<<Si as Sink>::SinkItem, <Si as Sink>::SinkError>>,  type Output = Result<Si, <Si as Sink>::SinkError>;

• impl<'_, St> Future for TryNext<'_, St> where     St: Unpin + TryStream,  type Output = Result<Option<<St as TryStream>::Ok>, <St as TryStream>::Error>;

• impl<Fut> Future for IntoFuture<Fut> where     Fut: TryFuture,  type Output = Result<<Fut as TryFuture>::Ok, <Fut as TryFuture>::Error>;

• impl<St, Fut, F> Future for TryForEach<St, Fut, F> where     F: FnMut(<St as TryStream>::Ok) -> Fut,     Fut: TryFuture<Ok = (), Error = <St as TryStream>::Error>,     St: TryStream,  type Output = Result<(), <St as TryStream>::Error>;

• impl<Fut> Future for Compat<Fut, ()> where     Fut: Future,  type Output = Result<<Fut as Future>::Item, <Fut as Future>::Error>;

• impl<St> Future for StreamFuture<St> where     St: Unpin + Stream,  type Output = (Option<<St as Stream>::Item>, St);

• impl<St, Fut, T, F> Future for TryFold<St, Fut, T, F> where     F: FnMut(T, <St as TryStream>::Ok) -> Fut,     Fut: TryFuture<Ok = T, Error = <St as TryStream>::Error>,     St: TryStream,  type Output = Result<T, <St as TryStream>::Error>;

• impl<'_, St> Future for Next<'_, St> where     St: Unpin + Stream,  type Output = Option<<St as Stream>::Item>;

• impl<Fut, F, T> Future for MapOk<Fut, F> where     F: FnOnce(<Fut as TryFuture>::Ok) -> T,     Fut: TryFuture,  type Output = Result<T, <Fut as TryFuture>::Error>;

• impl<'_, R> Future for ReadExact<'_, R> where     R: AsyncRead + ?Sized,  type Output = Result<(), Error>;

• impl<Fut1, Fut2, Fut3, Fut4, Fut5> Future for Join5<Fut1, Fut2, Fut3, Fut4, Fut5> where     Fut1: Future,     Fut2: Future,     Fut3: Future,     Fut4: Future,     Fut5: Future,  type Output = (<Fut1 as Future>::Output, <Fut2 as Future>::Output, <Fut3 as Future>::Output, <Fut4 as Future>::Output, <Fut5 as Future>::Output);

• impl<Fut1, Fut2, Fut3, Fut4> Future for TryJoin4<Fut1, Fut2, Fut3, Fut4> where     Fut1: TryFuture,     Fut2: TryFuture<Error = <Fut1 as TryFuture>::Error>,     Fut3: TryFuture<Error = <Fut1 as TryFuture>::Error>,     Fut4: TryFuture<Error = <Fut1 as TryFuture>::Error>,  type Output = Result<(<Fut1 as TryFuture>::Ok, <Fut2 as TryFuture>::Ok, <Fut3 as TryFuture>::Ok, <Fut4 as TryFuture>::Ok), <Fut1 as TryFuture>::Error>;

• impl<Fut> Future for Shared<Fut> where     Fut: Future,     <Fut as Future>::Output: Clone,  type Output = <Fut as Future>::Output;

• impl<Fut1, Fut2> Future for TryJoin<Fut1, Fut2> where     Fut1: TryFuture,     Fut2: TryFuture<Error = <Fut1 as TryFuture>::Error>,  type Output = Result<(<Fut1 as TryFuture>::Ok, <Fut2 as TryFuture>::Ok), <Fut1 as TryFuture>::Error>;

• impl<Fut, Sp> Future for WithSpawner<Fut, Sp> where     Fut: Future,     Sp: Spawn,  type Output = <Fut as Future>::Output;

• impl<T> Future for Empty<T> type Output = T;

• impl<St, Fut, F> Future for ForEach<St, Fut, F> where     F: FnMut(<St as Stream>::Item) -> Fut,     Fut: Future<Output = ()>,     St: Stream,  type Output = ();

• impl<'_, R> Future for Read<'_, R> where     R: AsyncRead + ?Sized,  type Output = Result<usize, Error>;

• impl<T, F> Future for PollFn<F> where     F: FnMut(&mut Context) -> Poll<T>,  type Output = T;

• impl<'_, Si> Future for Send<'_, Si> where     Si: Unpin + Sink + ?Sized,  type Output = Result<(), <Si as Sink>::SinkError>;

• impl<Fut, F> Future for Inspect<Fut, F> where     F: FnOnce(&<Fut as Future>::Output),     Fut: Future,  type Output = <Fut as Future>::Output;

• impl<St, C> Future for Collect<St, C> where     C: Default + Extend<<St as Stream>::Item>,     St: Stream,  type Output = C;

• impl<Fut1, Fut2, F> Future for Then<Fut1, Fut2, F> where     F: FnOnce(<Fut1 as Future>::Output) -> Fut2,     Fut1: Future,     Fut2: Future,  type Output = <Fut2 as Future>::Output;

• impl<'_, Si, St> Future for SendAll<'_, Si, St> where     Si: Unpin + Sink + ?Sized,     St: Stream<Item = <Si as Sink>::SinkItem> + Unpin + ?Sized,  type Output = Result<(), <Si as Sink>::SinkError>;

• impl<Fut1, Fut2> Future for Join<Fut1, Fut2> where     Fut1: Future,     Fut2: Future,  type Output = (<Fut1 as Future>::Output, <Fut2 as Future>::Output);

• impl<Fut, F> Future for UnwrapOrElse<Fut, F> where     F: FnOnce(<Fut as TryFuture>::Error) -> <Fut as TryFuture>::Ok,     Fut: TryFuture,  type Output = <Fut as TryFuture>::Ok;

• 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;

• impl<'_, R, W> Future for CopyInto<'_, R, W> where     R: AsyncRead + ?Sized,     W: AsyncWrite + ?Sized,  type Output = Result<u64, Error>;

• impl<Fut, F, E> Future for MapErr<Fut, F> where     F: FnOnce(<Fut as TryFuture>::Error) -> E,     Fut: TryFuture,  type Output = Result<<Fut as TryFuture>::Ok, E>;

• impl<St, C> Future for TryCollect<St, C> where     C: Default + Extend<<St as TryStream>::Ok>,     St: TryStream,  type Output = Result<C, <St as TryStream>::Error>;

• impl<Fut> Future for CatchUnwind<Fut> where     Fut: Future + UnwindSafe,  type Output = Result<<Fut as Future>::Output, Box<Any + 'static + Send>>;

• impl<Fut, E> Future for ErrInto<Fut, E> where     Fut: TryFuture,     <Fut as TryFuture>::Error: Into<E>,  type Output = Result<<Fut as TryFuture>::Ok, E>;

• impl<Fut1, Fut2, F> Future for AndThen<Fut1, Fut2, F> where     F: FnOnce(<Fut1 as TryFuture>::Ok) -> Fut2,     Fut1: TryFuture,     Fut2: TryFuture<Error = <Fut1 as TryFuture>::Error>,  type Output = Result<<Fut2 as TryFuture>::Ok, <Fut2 as TryFuture>::Error>;

• impl<'_, Si> Future for futures::sink::Close<'_, Si> where     Si: Unpin + Sink + ?Sized,  type Output = Result<(), <Si as Sink>::SinkError>;

• impl<Fut> Future for Abortable<Fut> where     Fut: Future,  type Output = Result<<Fut as Future>::Output, Aborted>;

• impl<St, Fut, T, F> Future for Fold<St, Fut, T, F> where     F: FnMut(T, <St as Stream>::Item) -> Fut,     Fut: Future<Output = T>,     St: Stream,  type Output = T;

• impl<T> Future for Receiver<T> type Output = Result<T, Canceled>;