Struct either_future::EitherFuture

pub struct EitherFuture<LeftFuture, RightFuture>(_);

Implementations

impl<LeftFuture, RightFuture> EitherFuture<LeftFuture, RightFuture>

pub fn left(left_future: LeftFuture) -> Self

pub fn right(right_future: RightFuture) -> Self

Methods from Deref<Target = Either<LeftFuture, RightFuture>>

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<LeftFuture, RightFuture> Deref for EitherFuture<LeftFuture, RightFuture>

type Target = Either<LeftFuture, RightFuture>

The resulting type after dereferencing.

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

Dereferences the value.

impl<LeftFuture, RightFuture> DerefMut for EitherFuture<LeftFuture, RightFuture>

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

Mutably dereferences the value.

impl<LeftFuture, RightFuture> From<Either<LeftFuture, RightFuture>> for EitherFuture<LeftFuture, RightFuture>

fn from(either: Either<LeftFuture, RightFuture>) -> Self

Performs the conversion.

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>

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