Enum itertools::EitherOrBoth
source · 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>
impl<A, B> EitherOrBoth<A, B>
sourcepub fn is_left(&self) -> bool
pub fn is_left(&self) -> bool
If Left
, return true. Otherwise, return false.
Exclusive version of has_left
.
sourcepub fn is_right(&self) -> bool
pub fn is_right(&self) -> bool
If Right
, return true. Otherwise, return false.
Exclusive version of has_right
.
sourcepub fn left(self) -> Option<A>
pub fn left(self) -> Option<A>
If Left
, or Both
, return Some
with the left value. Otherwise, return None
.
sourcepub fn right(self) -> Option<B>
pub fn right(self) -> Option<B>
If Right
, or Both
, return Some
with the right value. Otherwise, return None
.
sourcepub fn left_and_right(self) -> (Option<A>, Option<B>)
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(..))
sourcepub fn just_left(self) -> Option<A>
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);
sourcepub fn just_right(self) -> Option<B>
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);
sourcepub fn both(self) -> Option<(A, B)>
pub fn both(self) -> Option<(A, B)>
If Both
, return Some
containing the left and right values. Otherwise, return None
.
sourcepub fn into_left(self) -> Awhere
B: Into<A>,
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.
sourcepub fn into_right(self) -> Bwhere
A: Into<B>,
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.
sourcepub fn as_ref(&self) -> EitherOrBoth<&A, &B>
pub fn as_ref(&self) -> EitherOrBoth<&A, &B>
Converts from &EitherOrBoth<A, B>
to EitherOrBoth<&A, &B>
.
sourcepub fn as_mut(&mut self) -> EitherOrBoth<&mut A, &mut B>
pub fn as_mut(&mut self) -> EitherOrBoth<&mut A, &mut B>
Converts from &mut EitherOrBoth<A, B>
to EitherOrBoth<&mut A, &mut B>
.
sourcepub fn as_deref(&self) -> EitherOrBoth<&A::Target, &B::Target>
pub fn as_deref(&self) -> EitherOrBoth<&A::Target, &B::Target>
Converts from &EitherOrBoth<A, B>
to EitherOrBoth<&_, &_>
using the Deref
trait.
sourcepub fn as_deref_mut(&mut self) -> EitherOrBoth<&mut A::Target, &mut B::Target>
pub fn as_deref_mut(&mut self) -> EitherOrBoth<&mut A::Target, &mut B::Target>
Converts from &mut EitherOrBoth<A, B>
to EitherOrBoth<&mut _, &mut _>
using the DerefMut
trait.
sourcepub fn flip(self) -> EitherOrBoth<B, A>
pub fn flip(self) -> EitherOrBoth<B, A>
Convert EitherOrBoth<A, B>
to EitherOrBoth<B, A>
.
sourcepub fn map_left<F, M>(self, f: F) -> EitherOrBoth<M, B>where
F: FnOnce(A) -> M,
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.
sourcepub fn map_right<F, M>(self, f: F) -> EitherOrBoth<A, M>where
F: FnOnce(B) -> M,
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.
sourcepub fn map_any<F, L, G, R>(self, f: F, g: G) -> EitherOrBoth<L, R>
pub fn map_any<F, L, G, R>(self, f: F, g: G) -> EitherOrBoth<L, 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.
sourcepub fn left_and_then<F, L>(self, f: F) -> EitherOrBoth<L, B>where
F: FnOnce(A) -> EitherOrBoth<L, B>,
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.
sourcepub fn right_and_then<F, R>(self, f: F) -> EitherOrBoth<A, R>where
F: FnOnce(B) -> EitherOrBoth<A, R>,
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.
sourcepub fn or(self, l: A, r: B) -> (A, B)
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));
sourcepub fn or_default(self) -> (A, B)
pub fn or_default(self) -> (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 default
for the other.
sourcepub fn or_else<L: FnOnce() -> A, R: FnOnce() -> B>(self, l: L, r: R) -> (A, B)
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));
sourcepub fn left_or_insert(&mut self, val: A) -> &mut A
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
.
sourcepub fn right_or_insert(&mut self, val: B) -> &mut B
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
.
sourcepub fn left_or_insert_with<F>(&mut self, f: F) -> &mut Awhere
F: FnOnce() -> A,
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.
sourcepub fn right_or_insert_with<F>(&mut self, f: F) -> &mut Bwhere
F: FnOnce() -> B,
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.
sourcepub fn insert_left(&mut self, val: A) -> &mut A
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"));
sourcepub fn insert_right(&mut self, val: B) -> &mut B
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));
sourcepub fn insert_both(&mut self, left: A, right: B) -> (&mut A, &mut B)
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>
impl<T> EitherOrBoth<T, T>
sourcepub fn reduce<F>(self, f: F) -> Twhere
F: FnOnce(T, 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§
source§impl<A: Clone, B: Clone> Clone for EitherOrBoth<A, B>
impl<A: Clone, B: Clone> Clone for EitherOrBoth<A, B>
source§fn clone(&self) -> EitherOrBoth<A, B>
fn clone(&self) -> EitherOrBoth<A, B>
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moresource§impl<A, B> From<Either<A, B>> for EitherOrBoth<A, B>
impl<A, B> From<Either<A, B>> for EitherOrBoth<A, B>
source§impl<A, B> From<EitherOrBoth<A, B>> for Option<Either<A, B>>
impl<A, B> From<EitherOrBoth<A, B>> for Option<Either<A, B>>
source§fn from(value: EitherOrBoth<A, B>) -> Self
fn from(value: EitherOrBoth<A, B>) -> Self
source§impl<A: PartialEq, B: PartialEq> PartialEq for EitherOrBoth<A, B>
impl<A: PartialEq, B: PartialEq> PartialEq for EitherOrBoth<A, B>
source§fn eq(&self, other: &EitherOrBoth<A, B>) -> bool
fn eq(&self, other: &EitherOrBoth<A, B>) -> bool
self
and other
values to be equal, and is used
by ==
.impl<A: Eq, B: Eq> Eq for EitherOrBoth<A, B>
impl<A, B> StructuralPartialEq for EitherOrBoth<A, B>
Auto Trait Implementations§
impl<A, B> Freeze for EitherOrBoth<A, B>
impl<A, B> RefUnwindSafe for EitherOrBoth<A, B>where
A: RefUnwindSafe,
B: RefUnwindSafe,
impl<A, B> Send for EitherOrBoth<A, B>
impl<A, B> Sync for EitherOrBoth<A, B>
impl<A, B> Unpin for EitherOrBoth<A, B>
impl<A, B> UnwindSafe for EitherOrBoth<A, B>where
A: UnwindSafe,
B: UnwindSafe,
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§default unsafe fn clone_to_uninit(&self, dst: *mut T)
default unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
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 moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
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