Struct EitherFuture

pub struct EitherFuture<Left, Right>(pub Either<Left, Right>);

Tuple Fields

0: Either<Left, Right>

Implementations

impl<Left, Right> EitherFuture<Left, Right>

pub fn left(left_future: Left) -> Self

pub fn right(right_future: Right) -> Self

Methods from Deref<Target = Either<Left, Right>>

pub fn is_left(&self) -> bool

Return true if the value is the Left variant.

use either::*;

let values = [Left(1), Right("the right value")];
assert_eq!(values[0].is_left(), true);
assert_eq!(values[1].is_left(), false);

pub fn is_right(&self) -> bool

Return true if the value is the Right variant.

use either::*;

let values = [Left(1), Right("the right value")];
assert_eq!(values[0].is_right(), false);
assert_eq!(values[1].is_right(), true);

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

Convert &Either<L, R> to Either<&L, &R>.

use either::*;

let left: Either<_, ()> = Left("some value");
assert_eq!(left.as_ref(), Left(&"some value"));

let right: Either<(), _> = Right("some value");
assert_eq!(right.as_ref(), Right(&"some value"));

pub fn as_mut(&mut self) -> Either<&mut L, &mut R>

Convert &mut Either<L, R> to Either<&mut L, &mut R>.

use either::*;

fn mutate_left(value: &mut Either<u32, u32>) {
    if let Some(l) = value.as_mut().left() {
        *l = 999;
    }
}

let mut left = Left(123);
let mut right = Right(123);
mutate_left(&mut left);
mutate_left(&mut right);
assert_eq!(left, Left(999));
assert_eq!(right, Right(123));

Trait Implementations

impl<Left, Right> Deref for EitherFuture<Left, Right>

type Target = Either<Left, Right>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<Left, Right> DerefMut for EitherFuture<Left, Right>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<Left, Right> From<Either<Left, Right>> for EitherFuture<Left, Right>

fn from(either: Either<Left, Right>) -> Self

Converts to this type from the input type.

impl<Left, Right> From<EitherFuture<Left, Right>> for Either<Left, Right>

fn from(either_future: EitherFuture<Left, Right>) -> Either<Left, Right>

Converts to this type from the input type.

impl<Left, Right, LeftFuture, RightFuture> Future for EitherFuture<LeftFuture, RightFuture>

where LeftFuture: Future<Output = Left>, RightFuture: Future<Output = Right>,

type Output = Either<Left, Right>

The type of value produced on completion.

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

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