Enum itertools::EitherOrBoth

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

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

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

pub fn has_left(&self) -> bool

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

pub fn has_right(&self) -> bool

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

pub fn is_left(&self) -> bool

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

pub fn is_right(&self) -> bool

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

pub fn is_both(&self) -> bool

If Both, return true. Otherwise, return false.

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

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

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

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

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(..))

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);

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);

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

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

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.

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.

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

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

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

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

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.

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.

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

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

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.

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.

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.

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.

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.

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));

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.

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));

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.

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.

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.

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.

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"));

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));

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.

impl<T> EitherOrBoth<T, T>

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

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

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

Converts to this type from the input type.

impl<A: Hash, B: Hash> Hash for EitherOrBoth<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, B> Into<Option<Either<A, B>>> for EitherOrBoth<A, B>

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

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

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

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

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

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.

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

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

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