wasm_timer

Trait TryFutureExt

Source 
pub trait TryFutureExt: TryFuture + Sized {
    // Provided methods
    fn timeout(self, dur: Duration) -> Timeout<Self> ⓘ
       where Self::Error: From<Error> { ... }
    fn timeout_at(self, at: Instant) -> Timeout<Self> ⓘ
       where Self::Error: From<Error> { ... }
}
Expand description

An extension trait for futures which provides convenient accessors for timing out execution and such.

Provided Methods§

Source

fn timeout(self, dur: Duration) -> Timeout<Self> ⓘ
where Self::Error: From<Error>,

Creates a new future which will take at most dur time to resolve from the point at which this method is called.

This combinator creates a new future which wraps the receiving future in a timeout. The future returned will resolve in at most dur time specified (relative to when this function is called).

If the future completes before dur elapses then the future will resolve with that item. Otherwise the future will resolve to an error once dur has elapsed.

§Examples
use std::time::Duration;
use futures::prelude::*;
use wasm_timer::TryFutureExt;

fn main() {
    let future = long_future();
    let timed_out = future.timeout(Duration::from_secs(1));

    async_std::task::block_on(async {
        match timed_out.await {
            Ok(item) => println!("got {:?} within enough time!", item),
            Err(_) => println!("took too long to produce the item"),
        }
    })
}
Source

fn timeout_at(self, at: Instant) -> Timeout<Self> ⓘ
where Self::Error: From<Error>,

Creates a new future which will resolve no later than at specified.

This method is otherwise equivalent to the timeout method except that it tweaks the moment at when the timeout elapsed to being specified with an absolute value rather than a relative one. For more documentation see the timeout method.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors§