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

fn has_left(self: &Self) -> bool

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

fn has_right(self: &Self) -> bool

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

fn is_left(self: &Self) -> bool

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

fn is_right(self: &Self) -> bool

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

fn is_both(self: &Self) -> bool

If Both, return true. Otherwise, return false.

fn left(self: Self) -> Option<A>

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

fn right(self: Self) -> Option<B>

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

fn left_and_right(self: 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: 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: 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: Self) -> Option<(A, B)>

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

fn into_left(self: 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: 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: &Self) -> EitherOrBoth<&A, &B>

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

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

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

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

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

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

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

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

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

fn map_left<F, M>(self: 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: 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: 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: 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: 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: 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: 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: 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(self: &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(self: &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>(self: &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>(self: &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(self: &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(self: &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(self: &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: 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 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

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

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

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

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

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

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

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

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

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

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

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

impl<A: $crate::clone::Clone, B: $crate::clone::Clone> Clone for EitherOrBoth<A, B>

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

impl<A: $crate::cmp::Eq, B: $crate::cmp::Eq> Eq for EitherOrBoth<A, B>

impl<A: $crate::cmp::PartialEq, B: $crate::cmp::PartialEq> PartialEq for EitherOrBoth<A, B>

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

impl<A: $crate::fmt::Debug, B: $crate::fmt::Debug> Debug for EitherOrBoth<A, B>

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

impl<A: $crate::hash::Hash, B: $crate::hash::Hash> Hash for EitherOrBoth<A, B>

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

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

fn type_id(self: &Self) -> TypeId

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

fn borrow(self: &Self) -> &T

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

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

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

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

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

fn from(t: T) -> T

Returns the argument unchanged.

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

fn to_owned(self: &Self) -> T

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

impl<T, U> Into for EitherOrBoth<A, B>

fn into(self: 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 for EitherOrBoth<A, B>

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

impl<T, U> TryInto for EitherOrBoth<A, B>

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