Enum actix_utils::future::Either

pub enum Either<L, R> {
    Left {
        value: L,
    },
    Right {
        value: R,
    },
}

Combines two different futures that have the same output type.

Construct variants with Either::left and Either::right.

Examples

use actix_utils::future::{ready, Ready, Either};

let res = Either::<_, Ready<usize>>::left(ready(42));
assert_eq!(res.await, 42);

let res = Either::<Ready<usize>, _>::right(ready(43));
assert_eq!(res.await, 43);

Variants

Left

Fields

value: L

A value of type L.

Right

Fields

value: R

A value of type R.

Implementations

impl<L, R> Either<L, R>

pub fn left(value: L) -> Either<L, R>

Creates new Either using left variant.

pub fn right(value: R) -> Either<L, R>

Creates new Either using right variant.

impl<T> Either<T, T>

pub fn into_inner(self) -> T

Unwraps into inner value when left and right have a common type.

Trait Implementations

impl<L: Clone, R: Clone> Clone for Either<L, R>

fn clone(&self) -> Either<L, R>

Returns a copy of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<L: Debug, R: Debug> Debug for Either<L, R>

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

Formats the value using the given formatter.

impl<L, R> Future for Either<L, R>where
    L: Future,
    R: Future<Output = L::Output>,

type Output = <L as Future>::Output

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<'__pin, L, R> Unpin for Either<L, R>where
    __Origin<'__pin, L, R>: Unpin,