# Enum itertools::either_or_both::EitherOrBoth

``````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, B> From<EitherOrBoth<A, B>> for Option<Either<A, B>>

source§

#### fn from(value: EitherOrBoth<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: PartialEq, B: PartialEq> PartialEq 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§

source§

§

§

§

§

§

§

## 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> IntoEither for T

source§

#### fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

Converts `self` into a `Left` variant of `Either<Self, Self>` if `into_left` is `true`. Converts `self` into a `Right` variant of `Either<Self, Self>` otherwise. Read more
source§

#### fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘwhere F: FnOnce(&Self) -> bool,

Converts `self` into a `Left` variant of `Either<Self, Self>` if `into_left(&self)` returns `true`. Converts `self` into a `Right` variant of `Either<Self, Self>` otherwise. Read more
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.