Enum actix::fut::Either

pub enum Either<A, B> {
    Left(A),
    Right(B),
}

Combines two different futures yielding the same item and error types into a single type.

Variants

Left(A)

Tuple Fields

0: A

First branch of the type

Right(B)

Tuple Fields

0: B

Second branch of the type

Implementations

impl<A, B, T> Either<(T, A), (T, B)>

pub fn factor_first(self) -> (T, Either<A, B>)

Factor out a homogeneous type from an either of pairs.

Here, the homogeneous type is the first element of the pairs.

impl<A, B, T> Either<(A, T), (B, T)>

pub fn factor_second(self) -> (Either<A, B>, T)

Factor out a homogeneous type from an either of pairs.

Here, the homogeneous type is the second element of the pairs.

impl<T> Either<T, T>

pub fn into_inner(self) -> T

Extract the value of an either over two equivalent types.

Trait Implementations

impl<A, B> ActorFuture for Either<A, B> where
    A: ActorFuture,
    B: ActorFuture<Output = A::Output, Actor = A::Actor>, 

type Output = A::Output

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

type Actor = A::Actor

The actor within which this future runs

fn poll(
    self: Pin<&mut Self>,
    act: &mut A::Actor,
    ctx: &mut <A::Actor as Actor>::Context,
    task: &mut Context<'_>
) -> Poll<A::Output>

fn map<F, U>(self, f: F) -> Map<Self, F> where
    F: FnOnce(Self::Output, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> U,
    Self: Sized, 

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

fn then<F, B>(self, f: F) -> Then<Self, B, F> where
    F: FnOnce(Self::Output, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> B,
    B: IntoActorFuture<Actor = Self::Actor>,
    Self: Sized, 

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

fn timeout(self, timeout: Duration) -> Timeout<Self> where
    Self: Sized, 

Add timeout to futures chain.

impl<A: Debug, B: Debug> Debug for Either<A, B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'pin, A, B> Unpin for Either<A, B> where
    __Either<'pin, A, B>: Unpin, 

impl<A, B> UnsafeUnpin for Either<A, B>