Trait TryFutureExt

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> { ... }
}

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

Provided Methods

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"),
        }
    })
}

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

impl<F: TryFuture> TryFutureExt for F