Enum Either 

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

A type with two possile states, Left or Right.

It represents a disjunctive union.

Variants

Left(A)

Right(B)

Implementations

impl<A, B> Either<A, B>

pub fn branch(choice: bool) -> Either<A, B>

where A: Default, B: Default,

Chooses the branch of the either dependent on the boolean provided.

• true creates Left.
• false creates Right.

pub fn ok_into_left(result: Result<A, B>) -> Either<A, B>

Sets the left branch from a result assuming Ok, otherwise if Err sets the right branch instead.

pub fn ok_into_right(result: Result<B, A>) -> Either<A, B>

Sets the right branch from a result assuming Ok, otherwise if Err sets the left branch instead.

pub fn left(self) -> Result<A, B>

Moves out of the either, if left then the result is Ok, otherwise the result is an Err.

pub fn right(self) -> Result<B, A>

Moves out of the either, if right then the result is Ok, otherwise the result is an Err.

pub fn as_ref(&self) -> Either<&A, &B>

Converts from &Either<A, B> to Either<&A, &B>

pub fn as_mut(&mut self) -> Either<&mut A, &mut B>

Converts from &mut Either<A, B> to Either<&mut A, &mut B>

pub fn map_left<C>(self, left: impl FnOnce(A) -> C) -> Either<C, B>

Maps the left value.

This treats Either as a functor in the left type.

pub fn map_right<C>(self, right: impl FnOnce(B) -> C) -> Either<A, C>

Maps the left value.

This treats Either as a functor in the right type.

pub fn map_either<C, D>( self, left: impl FnOnce(A) -> C, right: impl FnOnce(B) -> D, ) -> Either<C, D>

Maps both values.

This treats Either as a functor in both the left and right types.

pub fn choose_map<C, D, F: FnOnce(A) -> C, G: FnOnce(B) -> D>( self, choice: impl Choice<Left = F, Right = G>, ) -> Either<C, D>

Composes an either with a choice of functions to produce an either of values.

This sequences the either and choice in a way that is unique to their structures.

pub fn compose<C, D>( self, choice: impl Choice<Left = C, Right = D>, ) -> Either<(A, C), (B, D)>

Composes an either with a choice of values to produce an either of values.

This sequences the either and choice in a way that is unique to their structures.

pub fn bind_left<C>(self, left: impl FnOnce(A) -> Either<C, B>) -> Either<C, B>

Maps the left if present to create a new either.

This treats Either as a monad in the left type.

pub fn bind_right<C>( self, right: impl FnOnce(B) -> Either<A, C>, ) -> Either<A, C>

Maps the right if present to create a new either.

This treats Either as a monad in the right type.

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

Swaps the left and right values.

pub fn either<C>( self, left: impl FnOnce(A) -> C, right: impl FnOnce(B) -> C, ) -> C

Handles each case of the either to produce a single value.

pub fn choose_either<C, F: FnOnce(A) -> C, G: FnOnce(B) -> C>( self, choice: impl Choice<Left = F, Right = G>, ) -> C

Composes an either with a choice of functions to produce a single value.

The composition of an either with its linear negative annihilates both.

pub fn factor<C, F: FnOnce(Either<A, B>) -> C>( consumer: F, ) -> ExclusiveFn<F, impl FnOnce(A) -> C, impl FnOnce(B) -> C>

Converts a consumer of an either into a choice of consumers.

pub fn distribute<C, F: FnOnce(A) -> C, G: FnOnce(B) -> C>( choice: impl Choice<Left = F, Right = G>, ) -> impl FnOnce(Either<A, B>) -> C

Converts a choice of consumers into a consumer of an either.

impl<A> Either<A, A>

pub fn converge(self) -> A

Consume an either with branches of same type to produce a single value.

Trait Implementations

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

fn clone(&self) -> Either<A, B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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<A: Hash, B: Hash> Hash for Either<A, B>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

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

fn cmp(&self, other: &Either<A, B>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

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

fn eq(&self, other: &Either<A, B>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

fn partial_cmp(&self, other: &Either<A, B>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

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

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

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