Enum EitherOrBoth

pub enum EitherOrBoth<A, B = A>

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>

fn has_left(&self) -> bool

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

fn has_right(&self) -> bool

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

fn is_left(&self) -> bool

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

fn is_right(&self) -> bool

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

fn is_both(&self) -> bool

If Both, return true. Otherwise, return false.

fn left(self) -> Option<A>

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

fn right(self) -> Option<B>

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

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

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.
# use itertools::{EitherOrBoth, EitherOrBoth::{Left, Right, Both}};
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);

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.
# use itertools::{EitherOrBoth::{Left, Right, Both}, EitherOrBoth};
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);

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

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

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

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

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

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

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

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

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

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

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.

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.

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

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

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.

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.

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.

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.

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.

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

# use itertools::EitherOrBoth;
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));

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.

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

# use itertools::EitherOrBoth;
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));

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.

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.

fn left_or_insert_with<F>(&mut self, f: F) -> &mut A
where
    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.

fn right_or_insert_with<F>(&mut self, f: F) -> &mut B
where
    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.

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

# use itertools::{EitherOrBoth, EitherOrBoth::{Left, Right, Both}};

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

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

# use itertools::{EitherOrBoth, EitherOrBoth::{Left, Both}};
// 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));

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>

fn reduce<F>(self, f: F) -> T
where
    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 preferably 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

# use itertools::EitherOrBoth;
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, B> From<Either<A, B>> for EitherOrBoth<A, B>

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

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

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

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

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

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

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

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

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

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

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

Auto Trait Implementations

impl<A, B> Freeze for EitherOrBoth<A, B> where A: Freeze + Freeze, B: Freeze + Freeze,

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

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

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

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

impl<A, B> UnsafeUnpin for EitherOrBoth<A, B> where A: UnsafeUnpin + UnsafeUnpin, B: UnsafeUnpin + UnsafeUnpin,

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

Blanket Implementations

impl<T> Any for EitherOrBoth<A, B> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for EitherOrBoth<A, B> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for EitherOrBoth<A, B> where T: ?Sized,

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

impl<T> CloneToUninit for EitherOrBoth<A, B> where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

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

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> IntoEither for EitherOrBoth<A, B>

impl<T> ToOwned for EitherOrBoth<A, B> where T: Clone,

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

impl<T, U> Into<U> for EitherOrBoth<A, B> where U: From<T>,

fn into(self) -> U

Calls U::from(self).

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

impl<T, U> TryFrom<U> for EitherOrBoth<A, B> where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for EitherOrBoth<A, B> where U: TryFrom<T>,

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