Struct futures::Fuse

pub struct Fuse<A> {
    // some fields omitted
}

A future which "fuse"s a future once it's been resolved.

Normally futures can behave unpredictable once they're used after a future has been resolved, but Fuse is always defined to return None from poll after it has succeeded, and after it has succeeded all future calls to schedule will be ignored.

Trait Implementations

impl<A: Future> Future for Fuse<A>

type Item = A::Item

The type of value that this future will resolved with if it is successful.

type Error = A::Error

The type of error that this future will resolve with if it fails in a normal fashion.

fn poll(&mut self, task: &mut Task) -> Poll<A::Item, A::Error>

Query this future to see if its value has become available.

fn schedule(&mut self, task: &mut Task)

Schedule a task to be notified when this future is ready.

fn tailcall(&mut self) -> Option<Box<Future<Item=Self::Item, Error=Self::Error>>>

Perform tail-call optimization on this future.

fn boxed(self) -> Box<Future<Item=Self::Item, Error=Self::Error>> where Self: Sized

Convenience function for turning this future into a trait object.

fn map<F, U>(self, f: F) -> Map<Self, F> where F: FnOnce(Self::Item) -> U + Send + 'static, U: Send + 'static, Self: Sized

Map this future's result to a different type, returning a new future of the resulting type.

fn map_err<F, E>(self, f: F) -> MapErr<Self, F> where F: FnOnce(Self::Error) -> E + Send + 'static, E: Send + 'static, Self: Sized

Map this future's error to a different error, returning a new future.

fn then<F, B>(self, f: F) -> Then<Self, B, F> where F: FnOnce(Result<Self::Item, Self::Error>) -> B + Send + 'static, B: IntoFuture, Self: Sized

Chain on a computation for when a future finished, passing the result of the future to the provided closure f.

fn and_then<F, B>(self, f: F) -> AndThen<Self, B, F> where F: FnOnce(Self::Item) -> B + Send + 'static, B: IntoFuture<Error=Self::Error>, Self: Sized

Execute another future after this one has resolved successfully.

fn or_else<F, B>(self, f: F) -> OrElse<Self, B, F> where F: FnOnce(Self::Error) -> B + Send + 'static, B: IntoFuture<Item=Self::Item>, Self: Sized

Execute another future after this one has resolved with an error.

fn select<B>(self, other: B) -> Select<Self, B::Future> where B: IntoFuture<Item=Self::Item, Error=Self::Error>, Self: Sized

Waits for either one of two futures to complete.

fn join<B>(self, other: B) -> Join<Self, B::Future> where B: IntoFuture<Error=Self::Error>, Self: Sized

Joins the result of two futures, waiting for them both to complete.

fn flatten(self) -> Flatten<Self> where Self::Item: IntoFuture, Self::Item::Error: From<Self::Error>, Self: Sized

Flatten the execution of this future when the successful result of this future is itself another future.

fn fuse(self) -> Fuse<Self> where Self: Sized

Fuse a future such that poll will never again be called once it has returned a success.

fn forget(self) where Self: Sized

Consume this future and allow it to execute without cancelling it.