Struct Delay 

pub struct Delay<F> { /* private fields */ }

A future that begins polling its inner future only after a specified delay.

When first polled, Delay waits for the given duration to elapse before starting to poll the inner future. After the delay has passed, it delegates all subsequent polls to the inner future until completion. This future begins counting the delay from the moment it is awaited.

This is useful for deferring the start of an asynchronous operation or spacing out tasks in time.

Implementations

impl<F> Delay<F>

pub fn new(future: F, delay: Duration) -> Self

Creates a new Delay that defers the execution of the given future.

The future will not be polled until the specified delay duration has elapsed since the first poll of the Delay itself. This is useful for postponing the start of an asynchronous operation by a fixed interval.

A more convenient way to construct this is via the delay() operator.

pub fn inner(self) -> F

Consumes the Delay and returns the inner future.

This allows access to the original future after the delay wrapper is no longer needed.

Trait Implementations

impl<F> Deref for Delay<F>

type Target = F

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<F> DerefMut for Delay<F>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<F> Future for Delay<F>

where F: Future,

type Output = <F as Future>::Output

The type of value produced on completion.

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

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

impl<'__pin, F> Unpin for Delay<F>

where PinnedFieldsOf<__Origin<'__pin, F>>: Unpin,