pub enum Either<L, R> {
Left(L),
Right(R),
}
Expand description
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
.
Implementations
sourceimpl<L, R> Either<L, R>
impl<L, R> Either<L, R>
sourcepub fn is_left(&self) -> bool
pub fn is_left(&self) -> bool
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);
sourcepub fn is_right(&self) -> bool
pub fn is_right(&self) -> bool
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);
sourcepub fn left(self) -> Option<L>
pub fn left(self) -> Option<L>
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);
sourcepub fn right(self) -> Option<R>
pub fn right(self) -> Option<R>
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));
sourcepub fn as_ref(&self) -> Either<&L, &R>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
pub fn as_ref(&self) -> Either<&L, &R>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
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"));
sourcepub fn as_mut(&mut self) -> Either<&mut L, &mut R>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
pub fn as_mut(&mut self) -> Either<&mut L, &mut R>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
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));
sourcepub fn as_pin_ref(self: Pin<&Self>) -> Either<Pin<&L>, Pin<&R>>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
pub fn as_pin_ref(self: Pin<&Self>) -> Either<Pin<&L>, Pin<&R>>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
Convert Pin<&Either<L, R>>
to Either<Pin<&L>, Pin<&R>>
,
pinned projections of the inner variants.
sourcepub fn as_pin_mut(self: Pin<&mut Self>) -> Either<Pin<&mut L>, Pin<&mut R>>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
pub fn as_pin_mut(self: Pin<&mut Self>) -> Either<Pin<&mut L>, Pin<&mut R>>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
Convert Pin<&mut Either<L, R>>
to Either<Pin<&mut L>, Pin<&mut R>>
,
pinned projections of the inner variants.
sourcepub fn flip(self) -> Either<R, L>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
pub fn flip(self) -> Either<R, L>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
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"));
sourcepub fn map_left<F, M>(self, f: F) -> Either<M, R>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
where
F: FnOnce(L) -> M,
pub fn map_left<F, M>(self, f: F) -> Either<M, R>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
where
F: FnOnce(L) -> M,
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
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));
sourcepub fn map_right<F, S>(self, f: F) -> Either<L, S>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
where
F: FnOnce(R) -> S,
pub fn map_right<F, S>(self, f: F) -> Either<L, S>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
where
F: FnOnce(R) -> S,
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
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));
sourcepub fn either<F, G, T>(self, f: F, g: G) -> Twhere
F: FnOnce(L) -> T,
G: FnOnce(R) -> T,
pub fn either<F, G, T>(self, f: F, g: G) -> Twhere
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);
sourcepub fn either_with<Ctx, F, G, T>(self, ctx: Ctx, f: F, g: G) -> Twhere
F: FnOnce(Ctx, L) -> T,
G: FnOnce(Ctx, R) -> T,
pub fn either_with<Ctx, F, G, T>(self, ctx: Ctx, f: F, g: G) -> Twhere
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]);
sourcepub fn left_and_then<F, S>(self, f: F) -> Either<S, R>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
where
F: FnOnce(L) -> Either<S, R>,
pub fn left_and_then<F, S>(self, f: F) -> Either<S, R>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
where
F: FnOnce(L) -> Either<S, R>,
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
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));
sourcepub fn right_and_then<F, S>(self, f: F) -> Either<L, S>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
where
F: FnOnce(R) -> Either<L, S>,
pub fn right_and_then<F, S>(self, f: F) -> Either<L, S>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
where
F: FnOnce(R) -> Either<L, S>,
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
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));
sourcepub fn into_iter(self) -> Either<L::IntoIter, R::IntoIter>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
where
L: IntoIterator,
R: IntoIterator<Item = L::Item>,
pub fn into_iter(self) -> Either<L::IntoIter, R::IntoIter>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
where
L: IntoIterator,
R: IntoIterator<Item = L::Item>,
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
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]));
sourcepub fn left_or(self, other: L) -> L
pub fn left_or(self, other: L) -> L
Return left value or given value
Arguments passed to left_or
are eagerly evaluated; if you are passing
the result of a function call, it is recommended to use left_or_else
,
which is lazily evaluated.
Examples
let left: Either<&str, &str> = Left("left");
assert_eq!(left.left_or("foo"), "left");
let right: Either<&str, &str> = Right("right");
assert_eq!(right.left_or("left"), "left");
sourcepub fn left_or_default(self) -> Lwhere
L: Default,
pub fn left_or_default(self) -> Lwhere
L: Default,
Return left or a default
Examples
let left: Either<String, u32> = Left("left".to_string());
assert_eq!(left.left_or_default(), "left");
let right: Either<String, u32> = Right(42);
assert_eq!(right.left_or_default(), String::default());
sourcepub fn left_or_else<F>(self, f: F) -> Lwhere
F: FnOnce(R) -> L,
pub fn left_or_else<F>(self, f: F) -> Lwhere
F: FnOnce(R) -> L,
Returns left value or computes it from a closure
Examples
let left: Either<String, u32> = Left("3".to_string());
assert_eq!(left.left_or_else(|_| unreachable!()), "3");
let right: Either<String, u32> = Right(3);
assert_eq!(right.left_or_else(|x| x.to_string()), "3");
sourcepub fn right_or(self, other: R) -> R
pub fn right_or(self, other: R) -> R
Return right value or given value
Arguments passed to right_or
are eagerly evaluated; if you are passing
the result of a function call, it is recommended to use right_or_else
,
which is lazily evaluated.
Examples
let right: Either<&str, &str> = Right("right");
assert_eq!(right.right_or("foo"), "right");
let left: Either<&str, &str> = Left("left");
assert_eq!(left.right_or("right"), "right");
sourcepub fn right_or_default(self) -> Rwhere
R: Default,
pub fn right_or_default(self) -> Rwhere
R: Default,
Return right or a default
Examples
let left: Either<String, u32> = Left("left".to_string());
assert_eq!(left.right_or_default(), u32::default());
let right: Either<String, u32> = Right(42);
assert_eq!(right.right_or_default(), 42);
sourcepub fn right_or_else<F>(self, f: F) -> Rwhere
F: FnOnce(L) -> R,
pub fn right_or_else<F>(self, f: F) -> Rwhere
F: FnOnce(L) -> R,
Returns right value or computes it from a closure
Examples
let left: Either<String, u32> = Left("3".to_string());
assert_eq!(left.right_or_else(|x| x.parse().unwrap()), 3);
let right: Either<String, u32> = Right(3);
assert_eq!(right.right_or_else(|_| unreachable!()), 3);
sourcepub fn unwrap_left(self) -> Lwhere
R: Debug,
pub fn unwrap_left(self) -> Lwhere
R: Debug,
sourcepub fn unwrap_right(self) -> Rwhere
L: Debug,
pub fn unwrap_right(self) -> Rwhere
L: Debug,
sourcepub fn expect_left(self, msg: &str) -> Lwhere
R: Debug,
pub fn expect_left(self, msg: &str) -> Lwhere
R: Debug,
sourcepub fn expect_right(self, msg: &str) -> Rwhere
L: Debug,
pub fn expect_right(self, msg: &str) -> Rwhere
L: Debug,
sourcepub fn either_into<T>(self) -> Twhere
L: Into<T>,
R: Into<T>,
pub fn either_into<T>(self) -> Twhere
L: Into<T>,
R: Into<T>,
Convert the contained value into T
Examples
// Both u16 and u32 can be converted to u64.
let left: Either<u16, u32> = Left(3u16);
assert_eq!(left.either_into::<u64>(), 3u64);
let right: Either<u16, u32> = Right(7u32);
assert_eq!(right.either_into::<u64>(), 7u64);
sourceimpl<L, R> Either<Option<L>, Option<R>>
impl<L, R> Either<Option<L>, Option<R>>
sourcepub fn factor_none(self) -> Option<Either<L, R>>
pub fn factor_none(self) -> Option<Either<L, R>>
Factors out None
from an Either
of [Option
].
use either::*;
let left: Either<_, Option<String>> = Left(Some(vec![0]));
assert_eq!(left.factor_none(), Some(Left(vec![0])));
let right: Either<Option<Vec<u8>>, _> = Right(Some(String::new()));
assert_eq!(right.factor_none(), Some(Right(String::new())));
sourceimpl<L, R, E> Either<Result<L, E>, Result<R, E>>
impl<L, R, E> Either<Result<L, E>, Result<R, E>>
sourcepub fn factor_err(self) -> Result<Either<L, R>, E>
pub fn factor_err(self) -> Result<Either<L, R>, E>
Factors out a homogenous type from an Either
of [Result
].
Here, the homogeneous type is the Err
type of the [Result
].
use either::*;
let left: Either<_, Result<String, u32>> = Left(Ok(vec![0]));
assert_eq!(left.factor_err(), Ok(Left(vec![0])));
let right: Either<Result<Vec<u8>, u32>, _> = Right(Ok(String::new()));
assert_eq!(right.factor_err(), Ok(Right(String::new())));
sourceimpl<T, L, R> Either<Result<T, L>, Result<T, R>>
impl<T, L, R> Either<Result<T, L>, Result<T, R>>
sourcepub fn factor_ok(self) -> Result<T, Either<L, R>>
pub fn factor_ok(self) -> Result<T, Either<L, R>>
Factors out a homogenous type from an Either
of [Result
].
Here, the homogeneous type is the Ok
type of the [Result
].
use either::*;
let left: Either<_, Result<u32, String>> = Left(Err(vec![0]));
assert_eq!(left.factor_ok(), Err(Left(vec![0])));
let right: Either<Result<u32, Vec<u8>>, _> = Right(Err(String::new()));
assert_eq!(right.factor_ok(), Err(Right(String::new())));
sourceimpl<T, L, R> Either<(T, L), (T, R)>
impl<T, L, R> Either<(T, L), (T, R)>
sourcepub fn factor_first(self) -> (T, Either<L, R>)
pub fn factor_first(self) -> (T, Either<L, R>)
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);
sourceimpl<T, L, R> Either<(L, T), (R, T)>
impl<T, L, R> Either<(L, T), (R, T)>
sourcepub fn factor_second(self) -> (Either<L, R>, T)
pub fn factor_second(self) -> (Either<L, R>, T)
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);
sourceimpl<T> Either<T, T>
impl<T> Either<T, T>
sourcepub fn into_inner(self) -> T
pub fn into_inner(self) -> T
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);
sourcepub fn map<F, M>(self, f: F) -> Either<M, M>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
where
F: FnOnce(T) -> M,
pub fn map<F, M>(self, f: F) -> Either<M, M>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
where
F: FnOnce(T) -> M,
L: Iterator,
R: Iterator<Item = L::Item>, type Item = L::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>, type Output = L::Output;
Map f
over the contained value and return the result in the
corresponding variant.
use either::*;
let value: Either<_, i32> = Right(42);
let other = value.map(|x| x * 2);
assert_eq!(other, Right(84));
Trait Implementations
sourceimpl<L, R, Target> AsMut<[Target]> for Either<L, R>where
L: AsMut<[Target]>,
R: AsMut<[Target]>,
impl<L, R, Target> AsMut<[Target]> for Either<L, R>where
L: AsMut<[Target]>,
R: AsMut<[Target]>,
sourceimpl<L, R> AsMut<CStr> for Either<L, R>where
L: AsMut<CStr>,
R: AsMut<CStr>,
impl<L, R> AsMut<CStr> for Either<L, R>where
L: AsMut<CStr>,
R: AsMut<CStr>,
Requires crate feature use_std
.
sourceimpl<L, R> AsMut<OsStr> for Either<L, R>where
L: AsMut<OsStr>,
R: AsMut<OsStr>,
impl<L, R> AsMut<OsStr> for Either<L, R>where
L: AsMut<OsStr>,
R: AsMut<OsStr>,
Requires crate feature use_std
.
sourceimpl<L, R> AsMut<Path> for Either<L, R>where
L: AsMut<Path>,
R: AsMut<Path>,
impl<L, R> AsMut<Path> for Either<L, R>where
L: AsMut<Path>,
R: AsMut<Path>,
Requires crate feature use_std
.
sourceimpl<L, R, Target> AsRef<[Target]> for Either<L, R>where
L: AsRef<[Target]>,
R: AsRef<[Target]>,
impl<L, R, Target> AsRef<[Target]> for Either<L, R>where
L: AsRef<[Target]>,
R: AsRef<[Target]>,
sourceimpl<L, R> AsRef<CStr> for Either<L, R>where
L: AsRef<CStr>,
R: AsRef<CStr>,
impl<L, R> AsRef<CStr> for Either<L, R>where
L: AsRef<CStr>,
R: AsRef<CStr>,
Requires crate feature use_std
.
sourceimpl<L, R> AsRef<OsStr> for Either<L, R>where
L: AsRef<OsStr>,
R: AsRef<OsStr>,
impl<L, R> AsRef<OsStr> for Either<L, R>where
L: AsRef<OsStr>,
R: AsRef<OsStr>,
Requires crate feature use_std
.
sourceimpl<L, R> AsRef<Path> for Either<L, R>where
L: AsRef<Path>,
R: AsRef<Path>,
impl<L, R> AsRef<Path> for Either<L, R>where
L: AsRef<Path>,
R: AsRef<Path>,
Requires crate feature use_std
.
sourceimpl<L, R> BufRead for Either<L, R>where
L: BufRead,
R: BufRead,
impl<L, R> BufRead for Either<L, R>where
L: BufRead,
R: BufRead,
Requires crate feature "use_std"
sourcefn fill_buf(&mut self) -> Result<&[u8]>
fn fill_buf(&mut self) -> Result<&[u8]>
sourcefn consume(&mut self, amt: usize)
fn consume(&mut self, amt: usize)
amt
bytes have been consumed from the buffer,
so they should no longer be returned in calls to read
. Read moresourcefn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> Result<usize>
fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> Result<usize>
sourcefn read_line(&mut self, buf: &mut String) -> Result<usize>
fn read_line(&mut self, buf: &mut String) -> Result<usize>
0xA
byte) is reached, and append
them to the provided buffer. You do not need to clear the buffer before
appending. Read morefn has_data_left(&mut self) -> Result<bool, Error>
fn has_data_left(&mut self) -> Result<bool, Error>
Read
has any data left to be read. Read moresourceimpl<L, R> DoubleEndedIterator for Either<L, R>where
L: DoubleEndedIterator,
R: DoubleEndedIterator<Item = L::Item>,
impl<L, R> DoubleEndedIterator for Either<L, R>where
L: DoubleEndedIterator,
R: DoubleEndedIterator<Item = L::Item>,
sourcefn next_back(&mut self) -> Option<Self::Item>
fn next_back(&mut self) -> Option<Self::Item>
sourcefn rfold<Acc, G>(self, init: Acc, f: G) -> Accwhere
G: FnMut(Acc, Self::Item) -> Acc,
fn rfold<Acc, G>(self, init: Acc, f: G) -> Accwhere
G: FnMut(Acc, Self::Item) -> Acc,
sourcefn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>where
P: FnMut(&Self::Item) -> bool,
fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>where
P: FnMut(&Self::Item) -> bool,
fn advance_back_by(&mut self, n: usize) -> Result<(), usize>
fn advance_back_by(&mut self, n: usize) -> Result<(), usize>
iter_advance_by
)n
elements. Read moresourceimpl<L, R> Error for Either<L, R>where
L: Error,
R: Error,
impl<L, R> Error for Either<L, R>where
L: Error,
R: Error,
Either
implements Error
if both L
and R
implement it.
sourcefn source(&self) -> Option<&(dyn Error + 'static)>
fn source(&self) -> Option<&(dyn Error + 'static)>
sourcefn description(&self) -> &str
fn description(&self) -> &str
sourceimpl<L, R> ExactSizeIterator for Either<L, R>where
L: ExactSizeIterator,
R: ExactSizeIterator<Item = L::Item>,
impl<L, R> ExactSizeIterator for Either<L, R>where
L: ExactSizeIterator,
R: ExactSizeIterator<Item = L::Item>,
sourceimpl<L, R, A> Extend<A> for Either<L, R>where
L: Extend<A>,
R: Extend<A>,
impl<L, R, A> Extend<A> for Either<L, R>where
L: Extend<A>,
R: Extend<A>,
sourcefn extend<T>(&mut self, iter: T)where
T: IntoIterator<Item = A>,
fn extend<T>(&mut self, iter: T)where
T: IntoIterator<Item = A>,
fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)sourceimpl<L, R> From<Result<R, L>> for Either<L, R>
impl<L, R> From<Result<R, L>> for Either<L, R>
Convert from Result
to Either
with Ok => Right
and Err => Left
.
sourceimpl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>,
impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = L::Output>,
Either<L, R>
is a future if both L
and R
are futures.
sourceimpl<L: Hash, R: Hash> Hash for Either<L, R>
impl<L: Hash, R: Hash> Hash for Either<L, R>
sourcefn hash<__H: Hasher>(&self, state: &mut __H)
fn hash<__H: Hasher>(&self, state: &mut __H)
Hasher
]. Read more1.3.0fn hash_slice<H>(data: &[Self], state: &mut H)where
H: Hasher,
fn hash_slice<H>(data: &[Self], state: &mut H)where
H: Hasher,
Hasher
]. Read moresourceimpl<L, R> Into<Result<R, L>> for Either<L, R>
impl<L, R> Into<Result<R, L>> for Either<L, R>
Convert from Either
to Result
with Right => Ok
and Left => Err
.
sourceimpl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = L::Item>,
impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = L::Item>,
Either<L, R>
is an iterator if both L
and R
are iterators.
type Item = <L as Iterator>::Item
type Item = <L as Iterator>::Item
sourcefn next(&mut self) -> Option<Self::Item>
fn next(&mut self) -> Option<Self::Item>
sourcefn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
sourcefn fold<Acc, G>(self, init: Acc, f: G) -> Accwhere
G: FnMut(Acc, Self::Item) -> Acc,
fn fold<Acc, G>(self, init: Acc, f: G) -> Accwhere
G: FnMut(Acc, Self::Item) -> Acc,
sourcefn for_each<F>(self, f: F)where
F: FnMut(Self::Item),
fn for_each<F>(self, f: F)where
F: FnMut(Self::Item),
sourcefn count(self) -> usize
fn count(self) -> usize
sourcefn last(self) -> Option<Self::Item>
fn last(self) -> Option<Self::Item>
sourcefn nth(&mut self, n: usize) -> Option<Self::Item>
fn nth(&mut self, n: usize) -> Option<Self::Item>
n
th element of the iterator. Read moresourcefn collect<B>(self) -> Bwhere
B: FromIterator<Self::Item>,
fn collect<B>(self) -> Bwhere
B: FromIterator<Self::Item>,
sourcefn partition<B, F>(self, f: F) -> (B, B)where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
fn partition<B, F>(self, f: F) -> (B, B)where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
sourcefn all<F>(&mut self, f: F) -> boolwhere
F: FnMut(Self::Item) -> bool,
fn all<F>(&mut self, f: F) -> boolwhere
F: FnMut(Self::Item) -> bool,
sourcefn any<F>(&mut self, f: F) -> boolwhere
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> boolwhere
F: FnMut(Self::Item) -> bool,
sourcefn find<P>(&mut self, predicate: P) -> Option<Self::Item>where
P: FnMut(&Self::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> Option<Self::Item>where
P: FnMut(&Self::Item) -> bool,
sourcefn find_map<B, F>(&mut self, f: F) -> Option<B>where
F: FnMut(Self::Item) -> Option<B>,
fn find_map<B, F>(&mut self, f: F) -> Option<B>where
F: FnMut(Self::Item) -> Option<B>,
sourcefn position<P>(&mut self, predicate: P) -> Option<usize>where
P: FnMut(Self::Item) -> bool,
fn position<P>(&mut self, predicate: P) -> Option<usize>where
P: FnMut(Self::Item) -> bool,
fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
iter_next_chunk
)N
values. Read morefn advance_by(&mut self, n: usize) -> Result<(), usize>
fn advance_by(&mut self, n: usize) -> Result<(), usize>
iter_advance_by
)n
elements. Read more1.28.0fn step_by(self, step: usize) -> StepBy<Self>
fn step_by(self, step: usize) -> StepBy<Self>
1.0.0fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>where
U: IntoIterator<Item = Self::Item>,
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>where
U: IntoIterator<Item = Self::Item>,
1.0.0fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
U: IntoIterator,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
U: IntoIterator,
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>where
G: FnMut() -> Self::Item,
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>where
G: FnMut() -> Self::Item,
iter_intersperse
)separator
between adjacent items of the original iterator. Read more1.0.0fn map<B, F>(self, f: F) -> Map<Self, F>where
F: FnMut(Self::Item) -> B,
fn map<B, F>(self, f: F) -> Map<Self, F>where
F: FnMut(Self::Item) -> B,
1.0.0fn filter<P>(self, predicate: P) -> Filter<Self, P>where
P: FnMut(&Self::Item) -> bool,
fn filter<P>(self, predicate: P) -> Filter<Self, P>where
P: FnMut(&Self::Item) -> bool,
1.0.0fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where
F: FnMut(Self::Item) -> Option<B>,
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where
F: FnMut(Self::Item) -> Option<B>,
1.0.0fn enumerate(self) -> Enumerate<Self>
fn enumerate(self) -> Enumerate<Self>
1.0.0fn peekable(self) -> Peekable<Self>
fn peekable(self) -> Peekable<Self>
1.0.0fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where
P: FnMut(&Self::Item) -> bool,
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where
P: FnMut(&Self::Item) -> bool,
1.0.0fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where
P: FnMut(&Self::Item) -> bool,
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where
P: FnMut(&Self::Item) -> bool,
1.57.0fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>where
P: FnMut(Self::Item) -> Option<B>,
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>where
P: FnMut(Self::Item) -> Option<B>,
1.0.0fn skip(self, n: usize) -> Skip<Self>
fn skip(self, n: usize) -> Skip<Self>
n
elements. Read more1.0.0fn take(self, n: usize) -> Take<Self>
fn take(self, n: usize) -> Take<Self>
n
elements, or fewer
if the underlying iterator ends sooner. Read more1.0.0fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where
F: FnMut(&mut St, Self::Item) -> Option<B>,
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.0fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where
U: IntoIterator,
F: FnMut(Self::Item) -> U,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where
U: IntoIterator,
F: FnMut(Self::Item) -> U,
1.0.0fn inspect<F>(self, f: F) -> Inspect<Self, F>where
F: FnMut(&Self::Item),
fn inspect<F>(self, f: F) -> Inspect<Self, F>where
F: FnMut(&Self::Item),
fn collect_into<E>(self, collection: &mut E) -> &mut Ewhere
E: Extend<Self::Item>,
fn collect_into<E>(self, collection: &mut E) -> &mut Ewhere
E: Extend<Self::Item>,
iter_collect_into
)fn is_partitioned<P>(self, predicate: P) -> boolwhere
P: FnMut(Self::Item) -> bool,
fn is_partitioned<P>(self, predicate: P) -> boolwhere
P: FnMut(Self::Item) -> bool,
iter_is_partitioned
)true
precede all those that return false
. Read more1.27.0fn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
1.27.0fn try_for_each<F, R>(&mut self, f: F) -> Rwhere
F: FnMut(Self::Item) -> R,
R: Try<Output = ()>,
fn try_for_each<F, R>(&mut self, f: F) -> Rwhere
F: FnMut(Self::Item) -> R,
R: Try<Output = ()>,
1.51.0fn reduce<F>(self, f: F) -> Option<Self::Item>where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
fn reduce<F>(self, f: F) -> Option<Self::Item>where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
fn try_reduce<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryTypewhere
F: FnMut(Self::Item, Self::Item) -> R,
R: Try<Output = Self::Item>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
fn try_reduce<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryTypewhere
F: FnMut(Self::Item, Self::Item) -> R,
R: Try<Output = Self::Item>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
iterator_try_reduce
)fn try_find<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryTypewhere
F: FnMut(&Self::Item) -> R,
R: Try<Output = bool>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
fn try_find<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryTypewhere
F: FnMut(&Self::Item) -> R,
R: Try<Output = bool>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
try_find
)1.6.0fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
F: FnMut(&Self::Item) -> B,
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.15.0fn max_by<F>(self, compare: F) -> Option<Self::Item>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn max_by<F>(self, compare: F) -> Option<Self::Item>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.6.0fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
F: FnMut(&Self::Item) -> B,
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.15.0fn min_by<F>(self, compare: F) -> Option<Self::Item>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_by<F>(self, compare: F) -> Option<Self::Item>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.0.0fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
1.36.0fn copied<'a, T>(self) -> Copied<Self>where
T: 'a + Copy,
Self: Iterator<Item = &'a T>,
fn copied<'a, T>(self) -> Copied<Self>where
T: 'a + Copy,
Self: Iterator<Item = &'a T>,
1.0.0fn cloned<'a, T>(self) -> Cloned<Self>where
T: 'a + Clone,
Self: Iterator<Item = &'a T>,
fn cloned<'a, T>(self) -> Cloned<Self>where
T: 'a + Clone,
Self: Iterator<Item = &'a T>,
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
iter_array_chunks
)N
elements of the iterator at a time. Read more1.11.0fn product<P>(self) -> Pwhere
P: Product<Self::Item>,
fn product<P>(self) -> Pwhere
P: Product<Self::Item>,
fn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
fn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
iter_order_by
)Iterator
] with those
of another with respect to the specified comparison function. Read more1.5.0fn partial_cmp<I>(self, other: I) -> Option<Ordering>where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn partial_cmp<I>(self, other: I) -> Option<Ordering>where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
iter_order_by
)Iterator
] with those
of another with respect to the specified comparison function. Read more1.5.0fn eq<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
fn eq<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
Iterator
] are equal to those of
another. Read morefn eq_by<I, F>(self, other: I, eq: F) -> boolwhere
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
fn eq_by<I, F>(self, other: I, eq: F) -> boolwhere
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
iter_order_by
)Iterator
] are equal to those of
another with respect to the specified equality function. Read more1.5.0fn ne<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
fn ne<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
Iterator
] are unequal to those of
another. Read more1.5.0fn lt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn lt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Iterator
] are lexicographically
less than those of another. Read more1.5.0fn le<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn le<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Iterator
] are lexicographically
less or equal to those of another. Read more1.5.0fn gt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn gt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Iterator
] are lexicographically
greater than those of another. Read more1.5.0fn ge<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn ge<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Iterator
] are lexicographically
greater than or equal to those of another. Read morefn is_sorted_by<F>(self, compare: F) -> boolwhere
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
fn is_sorted_by<F>(self, compare: F) -> boolwhere
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
is_sorted
)fn is_sorted_by_key<F, K>(self, f: F) -> boolwhere
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
fn is_sorted_by_key<F, K>(self, f: F) -> boolwhere
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
is_sorted
)sourceimpl<L: Ord, R: Ord> Ord for Either<L, R>
impl<L: Ord, R: Ord> Ord for Either<L, R>
sourceimpl<L: PartialEq, R: PartialEq> PartialEq<Either<L, R>> for Either<L, R>
impl<L: PartialEq, R: PartialEq> PartialEq<Either<L, R>> for Either<L, R>
sourceimpl<L: PartialOrd, R: PartialOrd> PartialOrd<Either<L, R>> for Either<L, R>
impl<L: PartialOrd, R: PartialOrd> PartialOrd<Either<L, R>> for Either<L, R>
sourcefn partial_cmp(&self, other: &Either<L, R>) -> Option<Ordering>
fn partial_cmp(&self, other: &Either<L, R>) -> Option<Ordering>
1.0.0const fn lt(&self, other: &Rhs) -> bool
const fn lt(&self, other: &Rhs) -> bool
1.0.0const fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read more1.0.0const fn gt(&self, other: &Rhs) -> bool
const fn gt(&self, other: &Rhs) -> bool
sourceimpl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
Either<L, R>
implements Read
if both L
and R
do.
Requires crate feature "use_std"
sourcefn read(&mut self, buf: &mut [u8]) -> Result<usize>
fn read(&mut self, buf: &mut [u8]) -> Result<usize>
sourcefn read_exact(&mut self, buf: &mut [u8]) -> Result<()>
fn read_exact(&mut self, buf: &mut [u8]) -> Result<()>
buf
. Read moresourcefn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize>
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize>
buf
. Read moresourcefn read_to_string(&mut self, buf: &mut String) -> Result<usize>
fn read_to_string(&mut self, buf: &mut String) -> Result<usize>
buf
. Read morefn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>
fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>
read
, except that it reads into a slice of buffers. Read morefn is_read_vectored(&self) -> bool
fn is_read_vectored(&self) -> bool
fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>
fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>
fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>
fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>
cursor
. Read morefn by_ref(&mut self) -> &mut Self
fn by_ref(&mut self) -> &mut Self
Read
. Read morefn bytes(self) -> Bytes<Self>
fn bytes(self) -> Bytes<Self>
sourceimpl<L, R> Seek for Either<L, R>where
L: Seek,
R: Seek,
impl<L, R> Seek for Either<L, R>where
L: Seek,
R: Seek,
Either<L, R>
implements Seek
if both L
and R
do.
Requires crate feature "use_std"
sourcefn seek(&mut self, pos: SeekFrom) -> Result<u64>
fn seek(&mut self, pos: SeekFrom) -> Result<u64>
fn stream_len(&mut self) -> Result<u64, Error>
fn stream_len(&mut self) -> Result<u64, Error>
fn stream_position(&mut self) -> Result<u64, Error>
fn stream_position(&mut self) -> Result<u64, Error>
sourceimpl<L, R> Write for Either<L, R>where
L: Write,
R: Write,
impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,
Either<L, R>
implements Write
if both L
and R
do.
Requires crate feature "use_std"