pub enum EitherOrBoth<A, B = A> {
    Both(A, B),
    Left(A),
    Right(B),
}
Expand description

Value that either holds a single A or B, or both.

Variants§

§

Both(A, B)

Both values are present.

§

Left(A)

Only the left value of type A is present.

§

Right(B)

Only the right value of type B is present.

Implementations§

source§

impl<A, B> EitherOrBoth<A, B>

source

pub fn has_left(&self) -> bool

If Left, or Both, return true. Otherwise, return false.

source

pub fn has_right(&self) -> bool

If Right, or Both, return true, otherwise, return false.

source

pub fn is_left(&self) -> bool

If Left, return true. Otherwise, return false. Exclusive version of has_left.

source

pub fn is_right(&self) -> bool

If Right, return true. Otherwise, return false. Exclusive version of has_right.

source

pub fn is_both(&self) -> bool

If Both, return true. Otherwise, return false.

source

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

If Left, or Both, return Some with the left value. Otherwise, return None.

source

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

If Right, or Both, return Some with the right value. Otherwise, return None.

source

pub fn left_and_right(self) -> (Option<A>, Option<B>)

Return tuple of options corresponding to the left and right value respectively

If Left return (Some(..), None), if Right return (None,Some(..)), else return (Some(..),Some(..))

source

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

If Left, return Some with the left value. If Right or Both, return None.

Examples
// On the `Left` variant.
let x: EitherOrBoth<_, ()> = Left("bonjour");
assert_eq!(x.just_left(), Some("bonjour"));

// On the `Right` variant.
let x: EitherOrBoth<(), _> = Right("hola");
assert_eq!(x.just_left(), None);

// On the `Both` variant.
let x = Both("bonjour", "hola");
assert_eq!(x.just_left(), None);
source

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

If Right, return Some with the right value. If Left or Both, return None.

Examples
// On the `Left` variant.
let x: EitherOrBoth<_, ()> = Left("auf wiedersehen");
assert_eq!(x.just_left(), Some("auf wiedersehen"));

// On the `Right` variant.
let x: EitherOrBoth<(), _> = Right("adios");
assert_eq!(x.just_left(), None);

// On the `Both` variant.
let x = Both("auf wiedersehen", "adios");
assert_eq!(x.just_left(), None);
source

pub fn both(self) -> Option<(A, B)>

If Both, return Some containing the left and right values. Otherwise, return None.

source

pub fn into_left(self) -> Awhere B: Into<A>,

If Left or Both, return the left value. Otherwise, convert the right value and return it.

source

pub fn into_right(self) -> Bwhere A: Into<B>,

If Right or Both, return the right value. Otherwise, convert the left value and return it.

source

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

Converts from &EitherOrBoth<A, B> to EitherOrBoth<&A, &B>.

source

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

Converts from &mut EitherOrBoth<A, B> to EitherOrBoth<&mut A, &mut B>.

source

pub fn as_deref(&self) -> EitherOrBoth<&A::Target, &B::Target>where A: Deref, B: Deref,

Converts from &EitherOrBoth<A, B> to EitherOrBoth<&_, &_> using the Deref trait.

source

pub fn as_deref_mut(&mut self) -> EitherOrBoth<&mut A::Target, &mut B::Target>where A: DerefMut, B: DerefMut,

Converts from &mut EitherOrBoth<A, B> to EitherOrBoth<&mut _, &mut _> using the DerefMut trait.

source

pub fn flip(self) -> EitherOrBoth<B, A>

Convert EitherOrBoth<A, B> to EitherOrBoth<B, A>.

source

pub fn map_left<F, M>(self, f: F) -> EitherOrBoth<M, B>where F: FnOnce(A) -> M,

Apply the function f on the value a in Left(a) or Both(a, b) variants. If it is present rewrapping the result in self’s original variant.

source

pub fn map_right<F, M>(self, f: F) -> EitherOrBoth<A, M>where F: FnOnce(B) -> M,

Apply the function f on the value b in Right(b) or Both(a, b) variants. If it is present rewrapping the result in self’s original variant.

source

pub fn map_any<F, L, G, R>(self, f: F, g: G) -> EitherOrBoth<L, R>where F: FnOnce(A) -> L, G: FnOnce(B) -> R,

Apply the functions f and g on the value a and b respectively; found in Left(a), Right(b), or Both(a, b) variants. The Result is rewrapped self’s original variant.

source

pub fn left_and_then<F, L>(self, f: F) -> EitherOrBoth<L, B>where F: FnOnce(A) -> EitherOrBoth<L, B>,

Apply the function f on the value a in Left(a) or Both(a, _) variants if it is present.

source

pub fn right_and_then<F, R>(self, f: F) -> EitherOrBoth<A, R>where F: FnOnce(B) -> EitherOrBoth<A, R>,

Apply the function f on the value b in Right(b) or Both(_, b) variants if it is present.

source

pub fn or(self, l: A, r: B) -> (A, B)

Returns a tuple consisting of the l and r in Both(l, r), if present. Otherwise, returns the wrapped value for the present element, and the supplied value for the other. The first (l) argument is used for a missing Left value. The second (r) argument is used for a missing Right value.

Arguments passed to or are eagerly evaluated; if you are passing the result of a function call, it is recommended to use or_else, which is lazily evaluated.

Examples
assert_eq!(EitherOrBoth::Both("tree", 1).or("stone", 5), ("tree", 1));
assert_eq!(EitherOrBoth::Left("tree").or("stone", 5), ("tree", 5));
assert_eq!(EitherOrBoth::Right(1).or("stone", 5), ("stone", 1));
source

pub fn or_default(self) -> (A, B)where A: Default, B: Default,

Returns a tuple consisting of the l and r in Both(l, r), if present. Otherwise, returns the wrapped value for the present element, and the default for the other.

source

pub fn or_else<L: FnOnce() -> A, R: FnOnce() -> B>(self, l: L, r: R) -> (A, B)

Returns a tuple consisting of the l and r in Both(l, r), if present. Otherwise, returns the wrapped value for the present element, and computes the missing value with the supplied closure. The first argument (l) is used for a missing Left value. The second argument (r) is used for a missing Right value.

Examples
let k = 10;
assert_eq!(EitherOrBoth::Both("tree", 1).or_else(|| "stone", || 2 * k), ("tree", 1));
assert_eq!(EitherOrBoth::Left("tree").or_else(|| "stone", || 2 * k), ("tree", 20));
assert_eq!(EitherOrBoth::Right(1).or_else(|| "stone", || 2 * k), ("stone", 1));
source

pub fn left_or_insert(&mut self, val: A) -> &mut A

Returns a mutable reference to the left value. If the left value is not present, it is replaced with val.

source

pub fn right_or_insert(&mut self, val: B) -> &mut B

Returns a mutable reference to the right value. If the right value is not present, it is replaced with val.

source

pub fn left_or_insert_with<F>(&mut self, f: F) -> &mut Awhere F: FnOnce() -> A,

If the left value is not present, replace it the value computed by the closure f. Returns a mutable reference to the now-present left value.

source

pub fn right_or_insert_with<F>(&mut self, f: F) -> &mut Bwhere F: FnOnce() -> B,

If the right value is not present, replace it the value computed by the closure f. Returns a mutable reference to the now-present right value.

source

pub fn insert_left(&mut self, val: A) -> &mut A

Sets the left value of this instance, and returns a mutable reference to it. Does not affect the right value.

Examples

// Overwriting a pre-existing value.
let mut either: EitherOrBoth<_, ()> = Left(0_u32);
assert_eq!(*either.insert_left(69), 69);

// Inserting a second value.
let mut either = Right("no");
assert_eq!(*either.insert_left("yes"), "yes");
assert_eq!(either, Both("yes", "no"));
source

pub fn insert_right(&mut self, val: B) -> &mut B

Sets the right value of this instance, and returns a mutable reference to it. Does not affect the left value.

Examples
// Overwriting a pre-existing value.
let mut either: EitherOrBoth<_, ()> = Left(0_u32);
assert_eq!(*either.insert_left(69), 69);

// Inserting a second value.
let mut either = Left("what's");
assert_eq!(*either.insert_right(9 + 10), 21 - 2);
assert_eq!(either, Both("what's", 9+10));
source

pub fn insert_both(&mut self, left: A, right: B) -> (&mut A, &mut B)

Set self to Both(..), containing the specified left and right values, and returns a mutable reference to those values.

source§

impl<T> EitherOrBoth<T, T>

source

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

Return either value of left, right, or apply a function f to both values if both are present. The input function has to return the same type as both Right and Left carry.

This function can be used to preferrably extract the left resp. right value, but fall back to the other (i.e. right resp. left) if the preferred one is not present.

Examples
assert_eq!(EitherOrBoth::Both(3, 7).reduce(u32::max), 7);
assert_eq!(EitherOrBoth::Left(3).reduce(u32::max), 3);
assert_eq!(EitherOrBoth::Right(7).reduce(u32::max), 7);

// Extract the left value if present, fall back to the right otherwise.
assert_eq!(EitherOrBoth::Left("left").reduce(|l, _r| l), "left");
assert_eq!(EitherOrBoth::Right("right").reduce(|l, _r| l), "right");
assert_eq!(EitherOrBoth::Both("left", "right").reduce(|l, _r| l), "left");

Trait Implementations§

source§

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

source§

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

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl<A: Debug, B: Debug> Debug for EitherOrBoth<A, B>

source§

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

Formats the value using the given formatter. Read more
source§

impl<A, B> From<Either<A, B>> for EitherOrBoth<A, B>

source§

fn from(either: Either<A, B>) -> Self

Converts to this type from the input type.
source§

impl<A: Hash, B: Hash> Hash for EitherOrBoth<A, B>

source§

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

Feeds this value into the given Hasher. Read more
1.3.0 · source§

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

Feeds a slice of this type into the given Hasher. Read more
source§

impl<A, B> Into<Option<Either<A, B>>> for EitherOrBoth<A, B>

source§

fn into(self) -> Option<Either<A, B>>

Converts this type into the (usually inferred) input type.
source§

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

source§

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

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

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

source§

impl<A, B> StructuralEq for EitherOrBoth<A, B>

source§

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

Auto Trait Implementations§

§

impl<A, B> RefUnwindSafe for EitherOrBoth<A, B>where A: RefUnwindSafe, B: RefUnwindSafe,

§

impl<A, B> Send for EitherOrBoth<A, B>where A: Send, B: Send,

§

impl<A, B> Sync for EitherOrBoth<A, B>where A: Sync, B: Sync,

§

impl<A, B> Unpin for EitherOrBoth<A, B>where A: Unpin, B: Unpin,

§

impl<A, B> UnwindSafe for EitherOrBoth<A, B>where A: UnwindSafe, B: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> ToOwned for Twhere T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.