Enum itertools::EitherOrBoth
source · pub enum EitherOrBoth<A, B> {
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 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.
§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);
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: 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