Enum swc_common::pass::Either
source · [−]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 as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
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 as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
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 as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
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 as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
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<&Either<L, R>>) -> 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 as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
pub fn as_pin_ref(self: Pin<&Either<L, R>>) -> 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 as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
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 Either<L, R>>
) -> 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 as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
pub fn as_pin_mut(
self: Pin<&mut Either<L, R>>
) -> 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 as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
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 as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
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 as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
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 as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
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 as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
where
F: FnOnce(L) -> M,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
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 as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
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 as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
where
F: FnOnce(R) -> S,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
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 as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
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 as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
where
F: FnOnce(L) -> Either<S, R>,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
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 as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
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 as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
where
F: FnOnce(R) -> Either<L, S>,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
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 as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
where
L: IntoIterator,
R: IntoIterator<Item = <L as IntoIterator>::Item>,
pub fn into_iter(
self
) -> Either<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
where
L: IntoIterator,
R: IntoIterator<Item = <L as IntoIterator>::Item>,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
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 as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
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 as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
where
F: FnOnce(T) -> M,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
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], Error>
fn fill_buf(&mut self) -> Result<&[u8], Error>
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_line(&mut self, buf: &mut String) -> Result<usize, Error>
fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>
0xA
byte) is reached, and append
them to the provided buffer. You do not need to clear the buffer before
appending. Read moresourcefn has_data_left(&mut self) -> Result<bool, Error>
fn has_data_left(&mut self) -> Result<bool, Error>
buf_read_has_data_left
)Read
has any data left to be read. Read moresourceimpl<L, R> Clone for Either<L, R>where
L: Clone,
R: Clone,
impl<L, R> Clone for Either<L, R>where
L: Clone,
R: Clone,
sourcefn clone(&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 as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
fn clone(&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 as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
sourcefn clone_from(&mut self, source: &Either<L, R>)
fn clone_from(&mut self, source: &Either<L, R>)
source
. Read moresourceimpl<L, R> Deref for Either<L, R>where
L: Deref,
R: Deref<Target = <L as Deref>::Target>,
impl<L, R> Deref for Either<L, R>where
L: Deref,
R: Deref<Target = <L as Deref>::Target>,
sourcefn deref(&self) -> &<Either<L, R> as Deref>::TargetⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
fn deref(&self) -> &<Either<L, R> as Deref>::TargetⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
sourceimpl<L, R> DerefMut for Either<L, R>where
L: DerefMut,
R: DerefMut<Target = <L as Deref>::Target>,
impl<L, R> DerefMut for Either<L, R>where
L: DerefMut,
R: DerefMut<Target = <L as Deref>::Target>,
sourcefn deref_mut(&mut self) -> &mut <Either<L, R> as Deref>::TargetⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
fn deref_mut(&mut self) -> &mut <Either<L, R> as Deref>::TargetⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
sourceimpl<L, R> DoubleEndedIterator for Either<L, R>where
L: DoubleEndedIterator,
R: DoubleEndedIterator<Item = <L as Iterator>::Item>,
impl<L, R> DoubleEndedIterator for Either<L, R>where
L: DoubleEndedIterator,
R: DoubleEndedIterator<Item = <L as Iterator>::Item>,
sourcefn next_back(&mut self) -> Option<<Either<L, R> as Iterator>::Item>
fn next_back(&mut self) -> Option<<Either<L, R> as Iterator>::Item>
sourcefn rfold<Acc, G>(self, init: Acc, f: G) -> Accwhere
G: FnMut(Acc, <Either<L, R> as Iterator>::Item) -> Acc,
fn rfold<Acc, G>(self, init: Acc, f: G) -> Accwhere
G: FnMut(Acc, <Either<L, R> as Iterator>::Item) -> Acc,
sourcefn rfind<P>(&mut self, predicate: P) -> Option<<Either<L, R> as Iterator>::Item>where
P: FnMut(&<Either<L, R> as Iterator>::Item) -> bool,
fn rfind<P>(&mut self, predicate: P) -> Option<<Either<L, R> as Iterator>::Item>where
P: FnMut(&<Either<L, R> as Iterator>::Item) -> bool,
sourcefn 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
use the Display impl or to_string()
sourceimpl<L, R> ExactSizeIterator for Either<L, R>where
L: ExactSizeIterator,
R: ExactSizeIterator<Item = <L as Iterator>::Item>,
impl<L, R> ExactSizeIterator for Either<L, R>where
L: ExactSizeIterator,
R: ExactSizeIterator<Item = <L as Iterator>::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>,
sourcefn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)sourcefn 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
.
sourcefn from(r: Result<R, L>) -> Either<L, R>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
fn from(r: Result<R, L>) -> Either<L, R>ⓘNotable traits for Either<L, R>impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>, type Item = <L as Iterator>::Item;impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>, type Output = <L as Future>::Output;impl<L, R> Write for Either<L, R>where
L: Write,
R: Write,impl<L, R> Read for Either<L, R>where
L: Read,
R: Read,
sourceimpl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>,
impl<L, R> Future for Either<L, R>where
L: Future,
R: Future<Output = <L as Future>::Output>,
Either<L, R>
is a future if both L
and R
are futures.
sourceimpl<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 as Iterator>::Item>,
impl<L, R> Iterator for Either<L, R>where
L: Iterator,
R: Iterator<Item = <L as Iterator>::Item>,
Either<L, R>
is an iterator if both L
and R
are iterators.
sourcefn next(&mut self) -> Option<<Either<L, R> as Iterator>::Item>
fn next(&mut self) -> Option<<Either<L, R> as Iterator>::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, <Either<L, R> as Iterator>::Item) -> Acc,
fn fold<Acc, G>(self, init: Acc, f: G) -> Accwhere
G: FnMut(Acc, <Either<L, R> as Iterator>::Item) -> Acc,
sourcefn for_each<F>(self, f: F)where
F: FnMut(<Either<L, R> as Iterator>::Item),
fn for_each<F>(self, f: F)where
F: FnMut(<Either<L, R> as Iterator>::Item),
sourcefn count(self) -> usize
fn count(self) -> usize
sourcefn last(self) -> Option<<Either<L, R> as Iterator>::Item>
fn last(self) -> Option<<Either<L, R> as Iterator>::Item>
sourcefn nth(&mut self, n: usize) -> Option<<Either<L, R> as Iterator>::Item>
fn nth(&mut self, n: usize) -> Option<<Either<L, R> as Iterator>::Item>
n
th element of the iterator. Read moresourcefn collect<B>(self) -> Bwhere
B: FromIterator<<Either<L, R> as Iterator>::Item>,
fn collect<B>(self) -> Bwhere
B: FromIterator<<Either<L, R> as Iterator>::Item>,
sourcefn partition<B, F>(self, f: F) -> (B, B)where
B: Default + Extend<<Either<L, R> as Iterator>::Item>,
F: FnMut(&<Either<L, R> as Iterator>::Item) -> bool,
fn partition<B, F>(self, f: F) -> (B, B)where
B: Default + Extend<<Either<L, R> as Iterator>::Item>,
F: FnMut(&<Either<L, R> as Iterator>::Item) -> bool,
sourcefn all<F>(&mut self, f: F) -> boolwhere
F: FnMut(<Either<L, R> as Iterator>::Item) -> bool,
fn all<F>(&mut self, f: F) -> boolwhere
F: FnMut(<Either<L, R> as Iterator>::Item) -> bool,
sourcefn any<F>(&mut self, f: F) -> boolwhere
F: FnMut(<Either<L, R> as Iterator>::Item) -> bool,
fn any<F>(&mut self, f: F) -> boolwhere
F: FnMut(<Either<L, R> as Iterator>::Item) -> bool,
sourcefn find<P>(&mut self, predicate: P) -> Option<<Either<L, R> as Iterator>::Item>where
P: FnMut(&<Either<L, R> as Iterator>::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> Option<<Either<L, R> as Iterator>::Item>where
P: FnMut(&<Either<L, R> as Iterator>::Item) -> bool,
sourcefn find_map<B, F>(&mut self, f: F) -> Option<B>where
F: FnMut(<Either<L, R> as Iterator>::Item) -> Option<B>,
fn find_map<B, F>(&mut self, f: F) -> Option<B>where
F: FnMut(<Either<L, R> as Iterator>::Item) -> Option<B>,
sourcefn position<P>(&mut self, predicate: P) -> Option<usize>where
P: FnMut(<Either<L, R> as Iterator>::Item) -> bool,
fn position<P>(&mut self, predicate: P) -> Option<usize>where
P: FnMut(<Either<L, R> as Iterator>::Item) -> bool,
sourcefn 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 moresourcefn 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.0 · sourcefn step_by(self, step: usize) -> StepBy<Self>
fn step_by(self, step: usize) -> StepBy<Self>
1.0.0 · sourcefn 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.0 · sourcefn 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,
sourcefn 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.0 · sourcefn 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.0 · sourcefn 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.0 · sourcefn 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.0 · sourcefn enumerate(self) -> Enumerate<Self>
fn enumerate(self) -> Enumerate<Self>
1.0.0 · sourcefn 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.0 · sourcefn 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.0 · sourcefn 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.0 · sourcefn skip(self, n: usize) -> Skip<Self>
fn skip(self, n: usize) -> Skip<Self>
n
elements. Read more1.0.0 · sourcefn 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.0 · sourcefn 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.0 · sourcefn 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.0 · sourcefn 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),
1.0.0 · sourcefn by_ref(&mut self) -> &mut Self
fn by_ref(&mut self) -> &mut Self
sourcefn 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
)sourcefn 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.0 · sourcefn 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.0 · sourcefn 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.0 · sourcefn 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,
sourcefn 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
)sourcefn 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.0 · sourcefn 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.0 · sourcefn 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.0 · sourcefn 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.0 · sourcefn 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.0 · sourcefn 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.0 · sourcefn 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.0 · sourcefn 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>,
sourcefn 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.0 · sourcefn sum<S>(self) -> Swhere
S: Sum<Self::Item>,
fn sum<S>(self) -> Swhere
S: Sum<Self::Item>,
1.11.0 · sourcefn product<P>(self) -> Pwhere
P: Product<Self::Item>,
fn product<P>(self) -> Pwhere
P: Product<Self::Item>,
sourcefn 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.0 · sourcefn 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>,
sourcefn 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.0 · sourcefn 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>,
sourcefn 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
)1.5.0 · sourcefn 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>,
1.5.0 · sourcefn 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.0 · sourcefn 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.0 · sourcefn 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.0 · sourcefn 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 moresourcefn 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
)sourcefn 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, R> Ord for Either<L, R>where
L: Ord,
R: Ord,
impl<L, R> Ord for Either<L, R>where
L: Ord,
R: Ord,
1.21.0 · sourcefn max(self, other: Self) -> Self
fn max(self, other: Self) -> Self
1.21.0 · sourcefn min(self, other: Self) -> Self
fn min(self, other: Self) -> Self
1.50.0 · sourcefn clamp(self, min: Self, max: Self) -> Selfwhere
Self: PartialOrd<Self>,
fn clamp(self, min: Self, max: Self) -> Selfwhere
Self: PartialOrd<Self>,
sourceimpl<L, R> PartialEq<Either<L, R>> for Either<L, R>where
L: PartialEq<L>,
R: PartialEq<R>,
impl<L, R> PartialEq<Either<L, R>> for Either<L, R>where
L: PartialEq<L>,
R: PartialEq<R>,
sourceimpl<L, R> PartialOrd<Either<L, R>> for Either<L, R>where
L: PartialOrd<L>,
R: PartialOrd<R>,
impl<L, R> PartialOrd<Either<L, R>> for Either<L, R>where
L: PartialOrd<L>,
R: PartialOrd<R>,
sourcefn partial_cmp(&self, other: &Either<L, R>) -> Option<Ordering>
fn partial_cmp(&self, other: &Either<L, R>) -> Option<Ordering>
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl<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, Error>
fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>
sourcefn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
buf
. Read moresourcefn read_to_end(&mut self, buf: &mut Vec<u8, Global>) -> Result<usize, Error>
fn read_to_end(&mut self, buf: &mut Vec<u8, Global>) -> Result<usize, Error>
buf
. Read moresourcefn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
buf
. Read more1.36.0 · sourcefn 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 moresourcefn is_read_vectored(&self) -> bool
fn is_read_vectored(&self) -> bool
can_vector
)sourcefn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>
fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>
read_buf
)sourcefn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>
fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>
read_buf
)cursor
. Read more1.0.0 · sourcefn by_ref(&mut self) -> &mut Self
fn by_ref(&mut self) -> &mut Self
Read
. Read moresourceimpl<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, Error>
fn seek(&mut self, pos: SeekFrom) -> Result<u64, Error>
1.55.0 · sourcefn rewind(&mut self) -> Result<(), Error>
fn rewind(&mut self) -> Result<(), 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"
sourcefn write(&mut self, buf: &[u8]) -> Result<usize, Error>
fn write(&mut self, buf: &[u8]) -> Result<usize, Error>
sourcefn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
sourcefn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>
fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>
sourcefn flush(&mut self) -> Result<(), Error>
fn flush(&mut self) -> Result<(), Error>
sourcefn is_write_vectored(&self) -> bool
fn is_write_vectored(&self) -> bool
can_vector
)impl<L, R> Copy for Either<L, R>where
L: Copy,
R: Copy,
impl<L, R> Eq for Either<L, R>where
L: Eq,
R: Eq,
impl<L, R> FusedIterator for Either<L, R>where
L: FusedIterator,
R: FusedIterator<Item = <L as Iterator>::Item>,
impl<L, R> StructuralEq for Either<L, R>
impl<L, R> StructuralPartialEq for Either<L, R>
Auto Trait Implementations
impl<L, R> RefUnwindSafe for Either<L, R>where
L: RefUnwindSafe,
R: RefUnwindSafe,
impl<L, R> Send for Either<L, R>where
L: Send,
R: Send,
impl<L, R> Sync for Either<L, R>where
L: Sync,
R: Sync,
impl<L, R> Unpin for Either<L, R>where
L: Unpin,
R: Unpin,
impl<L, R> UnwindSafe for Either<L, R>where
L: UnwindSafe,
R: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
sourceimpl<T> CallHasher for Twhere
T: Hash + ?Sized,
impl<T> CallHasher for Twhere
T: Hash + ?Sized,
sourceimpl<It> IdentifyLast for Itwhere
It: Iterator,
impl<It> IdentifyLast for Itwhere
It: Iterator,
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
sourcefn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
sourceimpl<F> IntoFuture for Fwhere
F: Future,
impl<F> IntoFuture for Fwhere
F: Future,
type IntoFuture = F
type IntoFuture = F
sourcefn into_future(self) -> <F as IntoFuture>::IntoFuture
fn into_future(self) -> <F as IntoFuture>::IntoFuture
sourceimpl<I> IntoIterator for Iwhere
I: Iterator,
impl<I> IntoIterator for Iwhere
I: Iterator,
sourceimpl<I> IteratorExt for Iwhere
I: Iterator,
impl<I> IteratorExt for Iwhere
I: Iterator,
sourcefn chain_with<F, I>(self, f: F) -> ChainWith<Self, F, I::IntoIter>ⓘNotable traits for ChainWith<B, F, I::IntoIter>impl<B, F, I> Iterator for ChainWith<B, F, I::IntoIter>where
B: Iterator,
F: FnOnce() -> I,
I: IntoIterator<Item = B::Item>, type Item = I::Item;
where
Self: Sized,
F: FnOnce() -> I,
I: IntoIterator<Item = Self::Item>,
fn chain_with<F, I>(self, f: F) -> ChainWith<Self, F, I::IntoIter>ⓘNotable traits for ChainWith<B, F, I::IntoIter>impl<B, F, I> Iterator for ChainWith<B, F, I::IntoIter>where
B: Iterator,
F: FnOnce() -> I,
I: IntoIterator<Item = B::Item>, type Item = I::Item;
where
Self: Sized,
F: FnOnce() -> I,
I: IntoIterator<Item = Self::Item>,
B: Iterator,
F: FnOnce() -> I,
I: IntoIterator<Item = B::Item>, type Item = I::Item;