[−][src]Enum either::Either
The enum Either
with variants Left
and Right
is a general purpose
sum type with two cases.
The Either
type is symmetric and treats its variants the same way, without
preference.
(For representing success or error, use the regular Result
enum instead.)
Variants
Left(L)
A value of type L
.
Right(R)
A value of type R
.
Methods
impl<L, R> Either<L, R>
[src]
pub fn is_left(&self) -> bool
[src]
Return true if the value is the Left
variant.
use either::*; let values = [Left(1), Right("the right value")]; assert_eq!(values[0].is_left(), true); assert_eq!(values[1].is_left(), false);
pub fn is_right(&self) -> bool
[src]
Return true if the value is the Right
variant.
use either::*; let values = [Left(1), Right("the right value")]; assert_eq!(values[0].is_right(), false); assert_eq!(values[1].is_right(), true);
pub fn left(self) -> Option<L>
[src]
Convert the left side of Either<L, R>
to an Option<L>
.
use either::*; let left: Either<_, ()> = Left("some value"); assert_eq!(left.left(), Some("some value")); let right: Either<(), _> = Right(321); assert_eq!(right.left(), None);
pub fn right(self) -> Option<R>
[src]
Convert the right side of Either<L, R>
to an Option<R>
.
use either::*; let left: Either<_, ()> = Left("some value"); assert_eq!(left.right(), None); let right: Either<(), _> = Right(321); assert_eq!(right.right(), Some(321));
ⓘImportant traits for Either<L, R>pub fn as_ref(&self) -> Either<&L, &R>
[src]
Convert &Either<L, R>
to Either<&L, &R>
.
use either::*; let left: Either<_, ()> = Left("some value"); assert_eq!(left.as_ref(), Left(&"some value")); let right: Either<(), _> = Right("some value"); assert_eq!(right.as_ref(), Right(&"some value"));
ⓘImportant traits for Either<L, R>pub fn as_mut(&mut self) -> Either<&mut L, &mut R>
[src]
Convert &mut Either<L, R>
to Either<&mut L, &mut R>
.
use either::*; fn mutate_left(value: &mut Either<u32, u32>) { if let Some(l) = value.as_mut().left() { *l = 999; } } let mut left = Left(123); let mut right = Right(123); mutate_left(&mut left); mutate_left(&mut right); assert_eq!(left, Left(999)); assert_eq!(right, Right(123));
ⓘImportant traits for Either<L, R>pub fn flip(self) -> Either<R, L>
[src]
Convert Either<L, R>
to Either<R, L>
.
use either::*; let left: Either<_, ()> = Left(123); assert_eq!(left.flip(), Right(123)); let right: Either<(), _> = Right("some value"); assert_eq!(right.flip(), Left("some value"));
ⓘImportant traits for Either<L, R>pub fn map_left<F, M>(self, f: F) -> Either<M, R> where
F: FnOnce(L) -> M,
[src]
F: FnOnce(L) -> M,
Apply the function f
on the value in the Left
variant if it is present rewrapping the
result in Left
.
use either::*; let left: Either<_, u32> = Left(123); assert_eq!(left.map_left(|x| x * 2), Left(246)); let right: Either<u32, _> = Right(123); assert_eq!(right.map_left(|x| x * 2), Right(123));
ⓘImportant traits for Either<L, R>pub fn map_right<F, S>(self, f: F) -> Either<L, S> where
F: FnOnce(R) -> S,
[src]
F: FnOnce(R) -> S,
Apply the function f
on the value in the Right
variant if it is present rewrapping the
result in Right
.
use either::*; let left: Either<_, u32> = Left(123); assert_eq!(left.map_right(|x| x * 2), Left(123)); let right: Either<u32, _> = Right(123); assert_eq!(right.map_right(|x| x * 2), Right(246));
pub fn either<F, G, T>(self, f: F, g: G) -> T where
F: FnOnce(L) -> T,
G: FnOnce(R) -> T,
[src]
F: FnOnce(L) -> T,
G: FnOnce(R) -> T,
Apply one of two functions depending on contents, unifying their result. If the value is
Left(L)
then the first function f
is applied; if it is Right(R)
then the second
function g
is applied.
use either::*; fn square(n: u32) -> i32 { (n * n) as i32 } fn negate(n: i32) -> i32 { -n } let left: Either<u32, i32> = Left(4); assert_eq!(left.either(square, negate), 16); let right: Either<u32, i32> = Right(-4); assert_eq!(right.either(square, negate), 4);
pub fn either_with<Ctx, F, G, T>(self, ctx: Ctx, f: F, g: G) -> T where
F: FnOnce(Ctx, L) -> T,
G: FnOnce(Ctx, R) -> T,
[src]
F: FnOnce(Ctx, L) -> T,
G: FnOnce(Ctx, R) -> T,
Like either
, but provide some context to whichever of the
functions ends up being called.
// In this example, the context is a mutable reference use either::*; let mut result = Vec::new(); let values = vec![Left(2), Right(2.7)]; for value in values { value.either_with(&mut result, |ctx, integer| ctx.push(integer), |ctx, real| ctx.push(f64::round(real) as i32)); } assert_eq!(result, vec![2, 3]);
ⓘImportant traits for Either<L, R>pub fn left_and_then<F, S>(self, f: F) -> Either<S, R> where
F: FnOnce(L) -> Either<S, R>,
[src]
F: FnOnce(L) -> Either<S, R>,
Apply the function f
on the value in the Left
variant if it is present.
use either::*; let left: Either<_, u32> = Left(123); assert_eq!(left.left_and_then::<_,()>(|x| Right(x * 2)), Right(246)); let right: Either<u32, _> = Right(123); assert_eq!(right.left_and_then(|x| Right::<(), _>(x * 2)), Right(123));
ⓘImportant traits for Either<L, R>pub fn right_and_then<F, S>(self, f: F) -> Either<L, S> where
F: FnOnce(R) -> Either<L, S>,
[src]
F: FnOnce(R) -> Either<L, S>,
Apply the function f
on the value in the Right
variant if it is present.
use either::*; let left: Either<_, u32> = Left(123); assert_eq!(left.right_and_then(|x| Right(x * 2)), Left(123)); let right: Either<u32, _> = Right(123); assert_eq!(right.right_and_then(|x| Right(x * 2)), Right(246));
ⓘImportant traits for Either<L, R>pub fn into_iter(self) -> Either<L::IntoIter, R::IntoIter> where
L: IntoIterator,
R: IntoIterator<Item = L::Item>,
[src]
L: IntoIterator,
R: IntoIterator<Item = L::Item>,
Convert the inner value to an iterator.
use either::*; let left: Either<_, Vec<u32>> = Left(vec![1, 2, 3, 4, 5]); let mut right: Either<Vec<u32>, _> = Right(vec![]); right.extend(left.into_iter()); assert_eq!(right, Right(vec![1, 2, 3, 4, 5]));
impl<T, L, R> Either<(T, L), (T, R)>
[src]
pub fn factor_first(self) -> (T, Either<L, R>)
[src]
Factor out a homogeneous type from an either of pairs.
Here, the homogeneous type is the first element of the pairs.
use either::*; let left: Either<_, (u32, String)> = Left((123, vec![0])); assert_eq!(left.factor_first().0, 123); let right: Either<(u32, Vec<u8>), _> = Right((123, String::new())); assert_eq!(right.factor_first().0, 123);
impl<T, L, R> Either<(L, T), (R, T)>
[src]
pub fn factor_second(self) -> (Either<L, R>, T)
[src]
Factor out a homogeneous type from an either of pairs.
Here, the homogeneous type is the second element of the pairs.
use either::*; let left: Either<_, (String, u32)> = Left((vec![0], 123)); assert_eq!(left.factor_second().1, 123); let right: Either<(Vec<u8>, u32), _> = Right((String::new(), 123)); assert_eq!(right.factor_second().1, 123);
impl<T> Either<T, T>
[src]
pub fn into_inner(self) -> T
[src]
Extract the value of an either over two equivalent types.
use either::*; let left: Either<_, u32> = Left(123); assert_eq!(left.into_inner(), 123); let right: Either<u32, _> = Right(123); assert_eq!(right.into_inner(), 123);
Trait Implementations
impl<L: Eq, R: Eq> Eq for Either<L, R>
[src]
impl<L: Copy, R: Copy> Copy for Either<L, R>
[src]
impl<L: PartialOrd, R: PartialOrd> PartialOrd<Either<L, R>> for Either<L, R>
[src]
fn partial_cmp(&self, other: &Either<L, R>) -> Option<Ordering>
[src]
fn lt(&self, other: &Either<L, R>) -> bool
[src]
fn le(&self, other: &Either<L, R>) -> bool
[src]
fn gt(&self, other: &Either<L, R>) -> bool
[src]
fn ge(&self, other: &Either<L, R>) -> bool
[src]
impl<L, R> AsMut<str> for Either<L, R> where
L: AsMut<str>,
R: AsMut<str>,
[src]
L: AsMut<str>,
R: AsMut<str>,
impl<L, R> AsMut<Path> for Either<L, R> where
L: AsMut<Path>,
R: AsMut<Path>,
[src]
L: AsMut<Path>,
R: AsMut<Path>,
Requires crate feature use_std
.
impl<L, R> AsMut<OsStr> for Either<L, R> where
L: AsMut<OsStr>,
R: AsMut<OsStr>,
[src]
L: AsMut<OsStr>,
R: AsMut<OsStr>,
Requires crate feature use_std
.
impl<L, R> AsMut<CStr> for Either<L, R> where
L: AsMut<CStr>,
R: AsMut<CStr>,
[src]
L: AsMut<CStr>,
R: AsMut<CStr>,
Requires crate feature use_std
.
impl<L, R, Target> AsMut<Target> for Either<L, R> where
L: AsMut<Target>,
R: AsMut<Target>,
[src]
L: AsMut<Target>,
R: AsMut<Target>,
impl<L, R, Target> AsMut<[Target]> for Either<L, R> where
L: AsMut<[Target]>,
R: AsMut<[Target]>,
[src]
L: AsMut<[Target]>,
R: AsMut<[Target]>,
fn as_mut(&mut self) -> &mut [Target]
[src]
impl<L, R> Iterator for Either<L, R> where
L: Iterator,
R: Iterator<Item = L::Item>,
[src]
L: Iterator,
R: Iterator<Item = L::Item>,
Either<L, R>
is an iterator if both L
and R
are iterators.
type Item = L::Item
The type of the elements being iterated over.
fn next(&mut self) -> Option<Self::Item>
[src]
fn size_hint(&self) -> (usize, Option<usize>)
[src]
fn fold<Acc, G>(self, init: Acc, f: G) -> Acc where
G: FnMut(Acc, Self::Item) -> Acc,
[src]
G: FnMut(Acc, Self::Item) -> Acc,
fn count(self) -> usize
[src]
fn last(self) -> Option<Self::Item>
[src]
fn nth(&mut self, n: usize) -> Option<Self::Item>
[src]
fn collect<B>(self) -> B where
B: FromIterator<Self::Item>,
[src]
B: FromIterator<Self::Item>,
fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
[src]
F: FnMut(Self::Item) -> bool,
default fn step_by(self, step: usize) -> StepBy<Self>
1.28.0[src]
Creates an iterator starting at the same point, but stepping by the given amount at each iteration. Read more
default fn chain<U>(
self,
other: U
) -> Chain<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator<Item = Self::Item>,
1.0.0[src]
self,
other: U
) -> Chain<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator<Item = Self::Item>,
Takes two iterators and creates a new iterator over both in sequence. Read more
default fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator,
1.0.0[src]
U: IntoIterator,
'Zips up' two iterators into a single iterator of pairs. Read more
default fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B,
1.0.0[src]
F: FnMut(Self::Item) -> B,
Takes a closure and creates an iterator which calls that closure on each element. Read more
default fn for_each<F>(self, f: F) where
F: FnMut(Self::Item),
1.21.0[src]
F: FnMut(Self::Item),
Calls a closure on each element of an iterator. Read more
default fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
Creates an iterator which uses a closure to determine if an element should be yielded. Read more
default fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>,
1.0.0[src]
F: FnMut(Self::Item) -> Option<B>,
Creates an iterator that both filters and maps. Read more
default fn enumerate(self) -> Enumerate<Self>
1.0.0[src]
Creates an iterator which gives the current iteration count as well as the next value. Read more
default fn peekable(self) -> Peekable<Self>
1.0.0[src]
Creates an iterator which can use peek
to look at the next element of the iterator without consuming it. Read more
default fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
Creates an iterator that [skip
]s elements based on a predicate. Read more
default fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
Creates an iterator that yields elements based on a predicate. Read more
default fn skip(self, n: usize) -> Skip<Self>
1.0.0[src]
Creates an iterator that skips the first n
elements. Read more
default fn take(self, n: usize) -> Take<Self>
1.0.0[src]
Creates an iterator that yields its first n
elements. Read more
default fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
F: FnMut(&mut St, Self::Item) -> Option<B>,
1.0.0[src]
F: FnMut(&mut St, Self::Item) -> Option<B>,
An iterator adaptor similar to [fold
] that holds internal state and produces a new iterator. Read more
default fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: IntoIterator,
1.0.0[src]
F: FnMut(Self::Item) -> U,
U: IntoIterator,
Creates an iterator that works like map, but flattens nested structure. Read more
default fn flatten(self) -> Flatten<Self> where
Self::Item: IntoIterator,
1.29.0[src]
Self::Item: IntoIterator,
Creates an iterator that flattens nested structure. Read more
default fn fuse(self) -> Fuse<Self>
1.0.0[src]
Creates an iterator which ends after the first [None
]. Read more
default fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
1.0.0[src]
F: FnMut(&Self::Item),
Do something with each element of an iterator, passing the value on. Read more
default fn by_ref(&mut self) -> &mut Self
1.0.0[src]
Borrows an iterator, rather than consuming it. Read more
default fn partition<B, F>(self, f: F) -> (B, B) where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
1.0.0[src]
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
Consumes an iterator, creating two collections from it. Read more
default fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
1.27.0[src]
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
An iterator method that applies a function as long as it returns successfully, producing a single, final value. Read more
default fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
1.27.0[src]
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
An iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error. Read more
default fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
1.0.0[src]
F: FnMut(Self::Item) -> bool,
Tests if any element of the iterator matches a predicate. Read more
default fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
Searches for an element of an iterator that satisfies a predicate. Read more
default fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>,
1.30.0[src]
F: FnMut(Self::Item) -> Option<B>,
Applies function to the elements of iterator and returns the first non-none result. Read more
default fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
1.0.0[src]
P: FnMut(Self::Item) -> bool,
Searches for an element in an iterator, returning its index. Read more
default fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator,
1.0.0[src]
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator,
Searches for an element in an iterator from the right, returning its index. Read more
default fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]
Self::Item: Ord,
Returns the maximum element of an iterator. Read more
default fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]
Self::Item: Ord,
Returns the minimum element of an iterator. Read more
default fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.6.0[src]
B: Ord,
F: FnMut(&Self::Item) -> B,
Returns the element that gives the maximum value from the specified function. Read more
default fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
Returns the element that gives the maximum value with respect to the specified comparison function. Read more
default fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.6.0[src]
B: Ord,
F: FnMut(&Self::Item) -> B,
Returns the element that gives the minimum value from the specified function. Read more
default fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
Returns the element that gives the minimum value with respect to the specified comparison function. Read more
default fn rev(self) -> Rev<Self> where
Self: DoubleEndedIterator,
1.0.0[src]
Self: DoubleEndedIterator,
Reverses an iterator's direction. Read more
default fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
1.0.0[src]
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
Converts an iterator of pairs into a pair of containers. Read more
default fn copied<'a, T>(self) -> Copied<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
[src]
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
iter_copied
)Creates an iterator which copies all of its elements. Read more
default fn cloned<'a, T>(self) -> Cloned<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
1.0.0[src]
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
Creates an iterator which [clone
]s all of its elements. Read more
default fn cycle(self) -> Cycle<Self> where
Self: Clone,
1.0.0[src]
Self: Clone,
Repeats an iterator endlessly. Read more
default fn sum<S>(self) -> S where
S: Sum<Self::Item>,
1.11.0[src]
S: Sum<Self::Item>,
Sums the elements of an iterator. Read more
default fn product<P>(self) -> P where
P: Product<Self::Item>,
1.11.0[src]
P: Product<Self::Item>,
Iterates over the entire iterator, multiplying all the elements Read more
default fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
1.5.0[src]
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
Lexicographically compares the elements of this Iterator
with those of another. Read more
default fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Lexicographically compares the elements of this Iterator
with those of another. Read more
default fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
Determines if the elements of this Iterator
are equal to those of another. Read more
default fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
Determines if the elements of this Iterator
are unequal to those of another. Read more
default fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Determines if the elements of this Iterator
are lexicographically less than those of another. Read more
default fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Determines if the elements of this Iterator
are lexicographically less or equal to those of another. Read more
default fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Determines if the elements of this Iterator
are lexicographically greater than those of another. Read more
default fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Determines if the elements of this Iterator
are lexicographically greater than or equal to those of another. Read more
default fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>,
[src]
Self::Item: PartialOrd<Self::Item>,
🔬 This is a nightly-only experimental API. (is_sorted
)
new API
Checks if the elements of this iterator are sorted. Read more
default fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
[src]
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
🔬 This is a nightly-only experimental API. (is_sorted
)
new API
Checks if the elements of this iterator are sorted using the given comparator function. Read more
default fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(&Self::Item) -> K,
K: PartialOrd<K>,
[src]
F: FnMut(&Self::Item) -> K,
K: PartialOrd<K>,
🔬 This is a nightly-only experimental API. (is_sorted
)
new API
Checks if the elements of this iterator are sorted using the given key extraction function. Read more
impl<L, R> ExactSizeIterator for Either<L, R> where
L: ExactSizeIterator,
R: ExactSizeIterator<Item = L::Item>,
[src]
L: ExactSizeIterator,
R: ExactSizeIterator<Item = L::Item>,
default fn len(&self) -> usize
1.0.0[src]
Returns the exact number of times the iterator will iterate. Read more
default fn is_empty(&self) -> bool
[src]
exact_size_is_empty
)Returns true
if the iterator is empty. Read more
impl<L: PartialEq, R: PartialEq> PartialEq<Either<L, R>> for Either<L, R>
[src]
impl<L, R, Target> AsRef<Target> for Either<L, R> where
L: AsRef<Target>,
R: AsRef<Target>,
[src]
L: AsRef<Target>,
R: AsRef<Target>,
impl<L, R> AsRef<str> for Either<L, R> where
L: AsRef<str>,
R: AsRef<str>,
[src]
L: AsRef<str>,
R: AsRef<str>,
impl<L, R> AsRef<Path> for Either<L, R> where
L: AsRef<Path>,
R: AsRef<Path>,
[src]
L: AsRef<Path>,
R: AsRef<Path>,
Requires crate feature use_std
.
impl<L, R> AsRef<OsStr> for Either<L, R> where
L: AsRef<OsStr>,
R: AsRef<OsStr>,
[src]
L: AsRef<OsStr>,
R: AsRef<OsStr>,
Requires crate feature use_std
.
impl<L, R> AsRef<CStr> for Either<L, R> where
L: AsRef<CStr>,
R: AsRef<CStr>,
[src]
L: AsRef<CStr>,
R: AsRef<CStr>,
Requires crate feature use_std
.
impl<L, R, Target> AsRef<[Target]> for Either<L, R> where
L: AsRef<[Target]>,
R: AsRef<[Target]>,
[src]
L: AsRef<[Target]>,
R: AsRef<[Target]>,
impl<L, R> DoubleEndedIterator for Either<L, R> where
L: DoubleEndedIterator,
R: DoubleEndedIterator<Item = L::Item>,
[src]
L: DoubleEndedIterator,
R: DoubleEndedIterator<Item = L::Item>,
fn next_back(&mut self) -> Option<Self::Item>
[src]
default fn nth_back(&mut self, n: usize) -> Option<Self::Item>
[src]
iter_nth_back
)Returns the n
th element from the end of the iterator. Read more
default fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
1.27.0[src]
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
This is the reverse version of [try_fold()
]: it takes elements starting from the back of the iterator. Read more
default fn rfold<B, F>(self, accum: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B,
1.27.0[src]
F: FnMut(B, Self::Item) -> B,
An iterator method that reduces the iterator's elements to a single, final value, starting from the back. Read more
default fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
1.27.0[src]
P: FnMut(&Self::Item) -> bool,
Searches for an element of an iterator from the back that satisfies a predicate. Read more
impl<L: Clone, R: Clone> Clone for Either<L, R>
[src]
ⓘImportant traits for Either<L, R>fn clone(&self) -> Either<L, R>
[src]
default fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl<L: Ord, R: Ord> Ord for Either<L, R>
[src]
fn cmp(&self, other: &Either<L, R>) -> Ordering
[src]
default fn max(self, other: Self) -> Self
1.21.0[src]
Compares and returns the maximum of two values. Read more
default fn min(self, other: Self) -> Self
1.21.0[src]
Compares and returns the minimum of two values. Read more
default fn clamp(self, min: Self, max: Self) -> Self
[src]
clamp
)Restrict a value to a certain interval. Read more
impl<L, R> From<Result<R, L>> for Either<L, R>
[src]
Convert from Result
to Either
with Ok => Right
and Err => Left
.
impl<L, R> Into<Result<R, L>> for Either<L, R>
[src]
Convert from Either
to Result
with Right => Ok
and Left => Err
.
impl<L, R, A> Extend<A> for Either<L, R> where
L: Extend<A>,
R: Extend<A>,
[src]
L: Extend<A>,
R: Extend<A>,
fn extend<T>(&mut self, iter: T) where
T: IntoIterator<Item = A>,
[src]
T: IntoIterator<Item = A>,
impl<L, R> Display for Either<L, R> where
L: Display,
R: Display,
[src]
L: Display,
R: Display,
impl<L: Debug, R: Debug> Debug for Either<L, R>
[src]
impl<L, R> Deref for Either<L, R> where
L: Deref,
R: Deref<Target = L::Target>,
[src]
L: Deref,
R: Deref<Target = L::Target>,
type Target = L::Target
The resulting type after dereferencing.
fn deref(&self) -> &Self::Target
[src]
impl<L: Hash, R: Hash> Hash for Either<L, R>
[src]
fn hash<__HLR: Hasher>(&self, state: &mut __HLR)
[src]
default fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
impl<L, R> DerefMut for Either<L, R> where
L: DerefMut,
R: DerefMut<Target = L::Target>,
[src]
L: DerefMut,
R: DerefMut<Target = L::Target>,
impl<L, R> Read for Either<L, R> where
L: Read,
R: Read,
[src]
L: Read,
R: Read,
Either<L, R>
implements Read
if both L
and R
do.
Requires crate feature "use_std"
fn read(&mut self, buf: &mut [u8]) -> Result<usize>
[src]
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize>
[src]
default fn read_vectored(
&mut self,
bufs: &mut [IoVecMut]
) -> Result<usize, Error>
[src]
&mut self,
bufs: &mut [IoVecMut]
) -> Result<usize, Error>
iovec
)Like read
, except that it reads into a slice of buffers. Read more
unsafe default fn initializer(&self) -> Initializer
[src]
read_initializer
)Determines if this Read
er can work with buffers of uninitialized memory. Read more
default fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
1.0.0[src]
Read all bytes until EOF in this source, appending them to buf
. Read more
default fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
1.6.0[src]
Read the exact number of bytes required to fill buf
. Read more
default fn by_ref(&mut self) -> &mut Self
1.0.0[src]
Creates a "by reference" adaptor for this instance of Read
. Read more
default fn bytes(self) -> Bytes<Self>
1.0.0[src]
Transforms this Read
instance to an [Iterator
] over its bytes. Read more
default fn chain<R>(self, next: R) -> Chain<Self, R> where
R: Read,
1.0.0[src]
R: Read,
Creates an adaptor which will chain this stream with another. Read more
default fn take(self, limit: u64) -> Take<Self>
1.0.0[src]
Creates an adaptor which will read at most limit
bytes from it. Read more
impl<L, R> Write for Either<L, R> where
L: Write,
R: Write,
[src]
L: Write,
R: Write,
Either<L, R>
implements Write
if both L
and R
do.
Requires crate feature "use_std"
fn write(&mut self, buf: &[u8]) -> Result<usize>
[src]
fn flush(&mut self) -> Result<()>
[src]
default fn write_vectored(&mut self, bufs: &[IoVec]) -> Result<usize, Error>
[src]
iovec
)Like write
, except that it writes from a slice of buffers. Read more
default fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
1.0.0[src]
Attempts to write an entire buffer into this writer. Read more
default fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>
1.0.0[src]
Writes a formatted string into this writer, returning any error encountered. Read more
default fn by_ref(&mut self) -> &mut Self
1.0.0[src]
Creates a "by reference" adaptor for this instance of Write
. Read more
impl<L, R> BufRead for Either<L, R> where
L: BufRead,
R: BufRead,
[src]
L: BufRead,
R: BufRead,
Requires crate feature "use_std"
fn fill_buf(&mut self) -> Result<&[u8]>
[src]
fn consume(&mut self, amt: usize)
[src]
default fn read_until(
&mut self,
byte: u8,
buf: &mut Vec<u8>
) -> Result<usize, Error>
1.0.0[src]
&mut self,
byte: u8,
buf: &mut Vec<u8>
) -> Result<usize, Error>
Read all bytes into buf
until the delimiter byte
or EOF is reached. Read more
default fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>
1.0.0[src]
Read all bytes until a newline (the 0xA byte) is reached, and append them to the provided buffer. Read more
default fn split(self, byte: u8) -> Split<Self>
1.0.0[src]
Returns an iterator over the contents of this reader split on the byte byte
. Read more
default fn lines(self) -> Lines<Self>
1.0.0[src]
Returns an iterator over the lines of this reader. Read more
impl<L, R> Error for Either<L, R> where
L: Error,
R: Error,
[src]
L: Error,
R: Error,
Either
implements Error
if both L
and R
implement it.
Auto Trait Implementations
impl<L, R> Send for Either<L, R> where
L: Send,
R: Send,
L: Send,
R: Send,
impl<L, R> Sync for Either<L, R> where
L: Sync,
R: Sync,
L: Sync,
R: Sync,
Blanket Implementations
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T> From for T
[src]
impl<I> IntoIterator for I where
I: Iterator,
[src]
I: Iterator,
type Item = <I as Iterator>::Item
The type of the elements being iterated over.
type IntoIter = I
Which kind of iterator are we turning this into?
fn into_iter(self) -> I
[src]
impl<T, U> Into for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T> Borrow for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T, U> TryInto for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,