Struct futures::SelectNext

pub struct SelectNext<A, B> where A: Future, B: Future<Item=A::Item, Error=A::Error> {
    // some fields omitted
}

Future yielded as the second result in a Select future.

This sentinel future represents the completion of the second future to a select which finished second.

Trait Implementations

impl<A, B> Future for SelectNext<A, B> where A: Future, B: Future<Item=A::Item, Error=A::Error>

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<Self::Item, Self::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.