Enum OxiEither 

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

A Rust-level sum type representing one of two values. Used by iterator utilities and functional combinators in this module.

Variants

Left(A)

The left variant (analogous to Either.inl).

Right(B)

The right variant (analogous to Either.inr).

Implementations

impl<A, B> OxiEither<A, B>

pub fn is_left(&self) -> bool

Check if this is a Left value.

pub fn is_right(&self) -> bool

Check if this is a Right value.

pub fn map_left<C, F: FnOnce(A) -> C>(self, f: F) -> OxiEither<C, B>

Map over the Left value.

pub fn map_right<C, F: FnOnce(B) -> C>(self, f: F) -> OxiEither<A, C>

Map over the Right value.

pub fn fold<C, FL: FnOnce(A) -> C, FR: FnOnce(B) -> C>( self, fl: FL, fr: FR, ) -> C

Fold into a single value using two functions.

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

Swap left and right.

pub fn left_or(self, default: A) -> A

Extract left value or use a default.

pub fn right_or(self, default: B) -> B

Extract right value or use a default.

pub fn left(self) -> Option<A>

Convert to Option of left.

pub fn right(self) -> Option<B>

Convert to Option of right.

pub fn as_left(&self) -> Option<&A>

Borrow the left value as an Option<&A>.

pub fn as_right(&self) -> Option<&B>

Borrow the right value as an Option<&B>.

impl<T> OxiEither<T, T>

pub fn merge<F: FnOnce(T) -> T>(self, f: F) -> T

Merge both sides using a function.

pub fn into_inner(self) -> T

Extract the value regardless of which side it’s on.

Trait Implementations

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

fn clone(&self) -> OxiEither<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 OxiEither<A, B>

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

Formats the value using the given formatter.

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

fn eq(&self, other: &OxiEither<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: Eq, B: Eq> Eq for OxiEither<A, B>

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