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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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_until(
&mut self,
byte: u8,
buf: &mut Vec<u8, Global>
) -> Result<usize, Error>
fn read_until(
&mut self,
byte: u8,
buf: &mut Vec<u8, Global>
) -> Result<usize, Error>
sourcefn 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 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> 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;
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;
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;
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>,
type Target = <L as Deref>::Target
type 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;
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;
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;
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;
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;
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;
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,
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 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>,
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
.
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;
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;
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;
sourceimpl<L, R, A, B> FromParallelIterator<Either<L, R>> for (A, B)where
L: Send,
R: Send,
A: Send + FromParallelIterator<L>,
B: Send + FromParallelIterator<R>,
impl<L, R, A, B> FromParallelIterator<Either<L, R>> for (A, B)where
L: Send,
R: Send,
A: Send + FromParallelIterator<L>,
B: Send + FromParallelIterator<R>,
sourcefn from_par_iter<I>(pi: I) -> Selfwhere
I: IntoParallelIterator<Item = Either<L, R>>,
fn from_par_iter<I>(pi: I) -> Selfwhere
I: IntoParallelIterator<Item = Either<L, R>>,
par_iter
. Read moresourceimpl<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.
type Output = <L as Future>::Output
type Output = <L as Future>::Output
sourceimpl<L, R> Hash for Either<L, R>where
L: Hash,
R: Hash,
impl<L, R> Hash for Either<L, R>where
L: Hash,
R: Hash,
sourcefn hash<__H>(&self, state: &mut __H)where
__H: Hasher,
fn hash<__H>(&self, state: &mut __H)where
__H: Hasher,
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> IndexedParallelIterator for Either<L, R>where
L: IndexedParallelIterator,
R: IndexedParallelIterator<Item = L::Item>,
impl<L, R> IndexedParallelIterator for Either<L, R>where
L: IndexedParallelIterator,
R: IndexedParallelIterator<Item = L::Item>,
sourcefn drive<C>(self, consumer: C) -> C::Resultwhere
C: Consumer<Self::Item>,
fn drive<C>(self, consumer: C) -> C::Resultwhere
C: Consumer<Self::Item>,
sourcefn len(&self) -> usize
fn len(&self) -> usize
sourcefn with_producer<CB>(self, callback: CB) -> CB::Outputwhere
CB: ProducerCallback<Self::Item>,
fn with_producer<CB>(self, callback: CB) -> CB::Outputwhere
CB: ProducerCallback<Self::Item>,
sourcefn collect_into_vec(self, target: &mut Vec<Self::Item>)
fn collect_into_vec(self, target: &mut Vec<Self::Item>)
sourcefn unzip_into_vecs<A, B>(self, left: &mut Vec<A>, right: &mut Vec<B>)where
Self: IndexedParallelIterator<Item = (A, B)>,
A: Send,
B: Send,
fn unzip_into_vecs<A, B>(self, left: &mut Vec<A>, right: &mut Vec<B>)where
Self: IndexedParallelIterator<Item = (A, B)>,
A: Send,
B: Send,
sourcefn zip<Z>(self, zip_op: Z) -> Zip<Self, Z::Iter>where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn zip<Z>(self, zip_op: Z) -> Zip<Self, Z::Iter>where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
(A, B)
, where the items A
are from
this iterator and B
are from the iterator given as argument.
Like the zip
method on ordinary iterators, if the two
iterators are of unequal length, you only get the items they
have in common. Read moresourcefn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, Z::Iter>where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, Z::Iter>where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
Zip
, but requires that both iterators have the same length. Read moresourcefn interleave<I>(self, other: I) -> Interleave<Self, I::Iter>where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn interleave<I>(self, other: I) -> Interleave<Self, I::Iter>where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
sourcefn interleave_shortest<I>(self, other: I) -> InterleaveShortest<Self, I::Iter>where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn interleave_shortest<I>(self, other: I) -> InterleaveShortest<Self, I::Iter>where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
sourcefn chunks(self, chunk_size: usize) -> Chunks<Self>
fn chunks(self, chunk_size: usize) -> Chunks<Self>
sourcefn fold_chunks<T, ID, F>(
self,
chunk_size: usize,
identity: ID,
fold_op: F
) -> FoldChunks<Self, ID, F>where
ID: Fn() -> T + Send + Sync,
F: Fn(T, Self::Item) -> T + Send + Sync,
T: Send,
fn fold_chunks<T, ID, F>(
self,
chunk_size: usize,
identity: ID,
fold_op: F
) -> FoldChunks<Self, ID, F>where
ID: Fn() -> T + Send + Sync,
F: Fn(T, Self::Item) -> T + Send + Sync,
T: Send,
sourcefn fold_chunks_with<T, F>(
self,
chunk_size: usize,
init: T,
fold_op: F
) -> FoldChunksWith<Self, T, F>where
T: Send + Clone,
F: Fn(T, Self::Item) -> T + Send + Sync,
fn fold_chunks_with<T, F>(
self,
chunk_size: usize,
init: T,
fold_op: F
) -> FoldChunksWith<Self, T, F>where
T: Send + Clone,
F: Fn(T, Self::Item) -> T + Send + Sync,
sourcefn partial_cmp<I>(self, other: I) -> Option<Ordering>where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn partial_cmp<I>(self, other: I) -> Option<Ordering>where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
ParallelIterator
with those of
another. Read moresourcefn eq<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn eq<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
ParallelIterator
are equal to those of another Read moresourcefn ne<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn ne<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
ParallelIterator
are unequal to those of another Read moresourcefn lt<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn lt<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
ParallelIterator
are lexicographically less than those of another. Read moresourcefn le<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn le<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
ParallelIterator
are less or equal to those of another. Read moresourcefn gt<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn gt<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
ParallelIterator
are lexicographically greater than those of another. Read moresourcefn ge<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn ge<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
ParallelIterator
are less or equal to those of another. Read moresourcefn step_by(self, step: usize) -> StepBy<Self>
fn step_by(self, step: usize) -> StepBy<Self>
sourcefn skip(self, n: usize) -> Skip<Self>
fn skip(self, n: usize) -> Skip<Self>
n
elements. Read moresourcefn take(self, n: usize) -> Take<Self>
fn take(self, n: usize) -> Take<Self>
n
elements. Read moresourcefn position_any<P>(self, predicate: P) -> Option<usize>where
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_any<P>(self, predicate: P) -> Option<usize>where
P: Fn(Self::Item) -> bool + Sync + Send,
ParallelIterator::find_any
, the parallel search will not
necessarily find the first match, and once a match is
found we’ll attempt to stop processing any more. Read moresourcefn position_first<P>(self, predicate: P) -> Option<usize>where
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_first<P>(self, predicate: P) -> Option<usize>where
P: Fn(Self::Item) -> bool + Sync + Send,
sourcefn position_last<P>(self, predicate: P) -> Option<usize>where
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_last<P>(self, predicate: P) -> Option<usize>where
P: Fn(Self::Item) -> bool + Sync + Send,
sourcefn positions<P>(self, predicate: P) -> Positions<Self, P>where
P: Fn(Self::Item) -> bool + Sync + Send,
fn positions<P>(self, predicate: P) -> Positions<Self, P>where
P: Fn(Self::Item) -> bool + Sync + Send,
sourcefn rev(self) -> Rev<Self>
fn rev(self) -> Rev<Self>
sourcefn with_min_len(self, min: usize) -> MinLen<Self>
fn with_min_len(self, min: usize) -> MinLen<Self>
sourcefn with_max_len(self, max: usize) -> MaxLen<Self>
fn with_max_len(self, max: usize) -> MaxLen<Self>
with_min_len()
.
For example, given min=10 and max=15, a length of 16 will not be
split any further. 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 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.
type Item = <L as Iterator>::Item
type Item = <L as Iterator>::Item
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,
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, R> Ord for Either<L, R>where
L: Ord,
R: Ord,
impl<L, R> Ord for Either<L, R>where
L: Ord,
R: Ord,
sourceimpl<L, R, A, B> ParallelExtend<Either<L, R>> for (A, B)where
L: Send,
R: Send,
A: Send + ParallelExtend<L>,
B: Send + ParallelExtend<R>,
impl<L, R, A, B> ParallelExtend<Either<L, R>> for (A, B)where
L: Send,
R: Send,
A: Send + ParallelExtend<L>,
B: Send + ParallelExtend<R>,
sourcefn par_extend<I>(&mut self, pi: I)where
I: IntoParallelIterator<Item = Either<L, R>>,
fn par_extend<I>(&mut self, pi: I)where
I: IntoParallelIterator<Item = Either<L, R>>,
par_iter
. Read moresourceimpl<L, R, T> ParallelExtend<T> for Either<L, R>where
L: ParallelExtend<T>,
R: ParallelExtend<T>,
T: Send,
impl<L, R, T> ParallelExtend<T> for Either<L, R>where
L: ParallelExtend<T>,
R: ParallelExtend<T>,
T: Send,
Either<L, R>
can be extended if both L
and R
are parallel extendable.
sourcefn par_extend<I>(&mut self, par_iter: I)where
I: IntoParallelIterator<Item = T>,
fn par_extend<I>(&mut self, par_iter: I)where
I: IntoParallelIterator<Item = T>,
par_iter
. Read moresourceimpl<L, R> ParallelIterator for Either<L, R>where
L: ParallelIterator,
R: ParallelIterator<Item = L::Item>,
impl<L, R> ParallelIterator for Either<L, R>where
L: ParallelIterator,
R: ParallelIterator<Item = L::Item>,
Either<L, R>
is a parallel iterator if both L
and R
are parallel iterators.
type Item = <L as ParallelIterator>::Item
type Item = <L as ParallelIterator>::Item
sourcefn drive_unindexed<C>(self, consumer: C) -> C::Resultwhere
C: UnindexedConsumer<Self::Item>,
fn drive_unindexed<C>(self, consumer: C) -> C::Resultwhere
C: UnindexedConsumer<Self::Item>,
sourcefn opt_len(&self) -> Option<usize>
fn opt_len(&self) -> Option<usize>
sourcefn for_each<OP>(self, op: OP)where
OP: Fn(Self::Item) + Sync + Send,
fn for_each<OP>(self, op: OP)where
OP: Fn(Self::Item) + Sync + Send,
OP
on each item produced by the iterator, in parallel. Read moresourcefn for_each_with<OP, T>(self, init: T, op: OP)where
OP: Fn(&mut T, Self::Item) + Sync + Send,
T: Send + Clone,
fn for_each_with<OP, T>(self, init: T, op: OP)where
OP: Fn(&mut T, Self::Item) + Sync + Send,
T: Send + Clone,
sourcefn for_each_init<OP, INIT, T>(self, init: INIT, op: OP)where
OP: Fn(&mut T, Self::Item) + Sync + Send,
INIT: Fn() -> T + Sync + Send,
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP)where
OP: Fn(&mut T, Self::Item) + Sync + Send,
INIT: Fn() -> T + Sync + Send,
OP
on a value returned by init
with each item produced by
the iterator, in parallel. Read moresourcefn try_for_each<OP, R>(self, op: OP) -> Rwhere
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Output = ()> + Send,
fn try_for_each<OP, R>(self, op: OP) -> Rwhere
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Output = ()> + Send,
OP
on each item produced by the iterator, in parallel. Read moresourcefn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> Rwhere
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Try<Output = ()> + Send,
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> Rwhere
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Try<Output = ()> + Send,
OP
on the given init
value with each item
produced by the iterator, in parallel. Read moresourcefn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> Rwhere
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Try<Output = ()> + Send,
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> Rwhere
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Try<Output = ()> + Send,
OP
on a value returned by init
with each item
produced by the iterator, in parallel. Read moresourcefn map<F, R>(self, map_op: F) -> Map<Self, F>where
F: Fn(Self::Item) -> R + Sync + Send,
R: Send,
fn map<F, R>(self, map_op: F) -> Map<Self, F>where
F: Fn(Self::Item) -> R + Sync + Send,
R: Send,
map_op
to each item of this iterator, producing a new
iterator with the results. Read moresourcefn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F>where
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Send,
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F>where
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Send,
map_op
to the given init
value with each item of this
iterator, producing a new iterator with the results. Read moresourcefn map_init<F, INIT, T, R>(self, init: INIT, map_op: F) -> MapInit<Self, INIT, F>where
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Send,
fn map_init<F, INIT, T, R>(self, init: INIT, map_op: F) -> MapInit<Self, INIT, F>where
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Send,
map_op
to a value returned by init
with each item of this
iterator, producing a new iterator with the results. Read moresourcefn cloned<'a, T>(self) -> Cloned<Self>where
T: 'a + Clone + Send,
Self: ParallelIterator<Item = &'a T>,
fn cloned<'a, T>(self) -> Cloned<Self>where
T: 'a + Clone + Send,
Self: ParallelIterator<Item = &'a T>,
sourcefn copied<'a, T>(self) -> Copied<Self>where
T: 'a + Copy + Send,
Self: ParallelIterator<Item = &'a T>,
fn copied<'a, T>(self) -> Copied<Self>where
T: 'a + Copy + Send,
Self: ParallelIterator<Item = &'a T>,
sourcefn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP>where
OP: Fn(&Self::Item) + Sync + Send,
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP>where
OP: Fn(&Self::Item) + Sync + Send,
inspect_op
to a reference to each item of this iterator,
producing a new iterator passing through the original items. This is
often useful for debugging to see what’s happening in iterator stages. Read moresourcefn update<F>(self, update_op: F) -> Update<Self, F>where
F: Fn(&mut Self::Item) + Sync + Send,
fn update<F>(self, update_op: F) -> Update<Self, F>where
F: Fn(&mut Self::Item) + Sync + Send,
sourcefn filter<P>(self, filter_op: P) -> Filter<Self, P>where
P: Fn(&Self::Item) -> bool + Sync + Send,
fn filter<P>(self, filter_op: P) -> Filter<Self, P>where
P: Fn(&Self::Item) -> bool + Sync + Send,
filter_op
to each item of this iterator, producing a new
iterator with only the items that gave true
results. Read moresourcefn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P>where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P>where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
filter_op
to each item of this iterator to get an Option
,
producing a new iterator with only the items from Some
results. Read moresourcefn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F>where
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F>where
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
map_op
to each item of this iterator to get nested parallel iterators,
producing a new parallel iterator that flattens these back into one. Read moresourcefn flat_map_iter<F, SI>(self, map_op: F) -> FlatMapIter<Self, F>where
F: Fn(Self::Item) -> SI + Sync + Send,
SI: IntoIterator,
SI::Item: Send,
fn flat_map_iter<F, SI>(self, map_op: F) -> FlatMapIter<Self, F>where
F: Fn(Self::Item) -> SI + Sync + Send,
SI: IntoIterator,
SI::Item: Send,
map_op
to each item of this iterator to get nested serial iterators,
producing a new parallel iterator that flattens these back into one. Read moresourcefn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Itemwhere
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
ID: Fn() -> Self::Item + Sync + Send,
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Itemwhere
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
ID: Fn() -> Self::Item + Sync + Send,
op
.
The argument identity
should be a closure that can produce
“identity” value which may be inserted into the sequence as
needed to create opportunities for parallel execution. So, for
example, if you are doing a summation, then identity()
ought
to produce something that represents the zero for your type
(but consider just calling sum()
in that case). Read moresourcefn reduce_with<OP>(self, op: OP) -> Option<Self::Item>where
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item>where
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
op
.
If the iterator is empty, None
is returned; otherwise,
Some
is returned. Read moresourcefn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F>where
F: Fn(T, Self::Item) -> T + Sync + Send,
ID: Fn() -> T + Sync + Send,
T: Send,
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F>where
F: Fn(T, Self::Item) -> T + Sync + Send,
ID: Fn() -> T + Sync + Send,
T: Send,
22 3 77 89 46
. If
you used sequential fold to add them (fold(0, |a,b| a+b)
,
you would wind up first adding 0 + 22, then 22 + 3, then 25 +
77, and so forth. The parallel fold works similarly except
that it first breaks up your list into sublists, and hence
instead of yielding up a single sum at the end, it yields up
multiple sums. The number of results is nondeterministic, as
is the point where the breaks occur. Read moresourcefn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F>where
F: Fn(T, Self::Item) -> T + Sync + Send,
T: Send + Clone,
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F>where
F: Fn(T, Self::Item) -> T + Sync + Send,
T: Send + Clone,
fold_op
to the given init
value with each item of this
iterator, finally producing the value for further use. Read moresourcefn try_fold<T, R, ID, F>(
self,
identity: ID,
fold_op: F
) -> TryFold<Self, R, ID, F>where
F: Fn(T, Self::Item) -> R + Sync + Send,
ID: Fn() -> T + Sync + Send,
R: Try<Output = T> + Send,
fn try_fold<T, R, ID, F>(
self,
identity: ID,
fold_op: F
) -> TryFold<Self, R, ID, F>where
F: Fn(T, Self::Item) -> R + Sync + Send,
ID: Fn() -> T + Sync + Send,
R: Try<Output = T> + Send,
sourcefn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F>where
F: Fn(T, Self::Item) -> R + Sync + Send,
R: Try<Output = T> + Send,
T: Clone + Send,
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F>where
F: Fn(T, Self::Item) -> R + Sync + Send,
R: Try<Output = T> + Send,
T: Clone + Send,
init
value. Read moresourcefn sum<S>(self) -> Swhere
S: Send + Sum<Self::Item> + Sum<S>,
fn sum<S>(self) -> Swhere
S: Send + Sum<Self::Item> + Sum<S>,
sourcefn product<P>(self) -> Pwhere
P: Send + Product<Self::Item> + Product<P>,
fn product<P>(self) -> Pwhere
P: Send + Product<Self::Item> + Product<P>,
sourcefn min_by<F>(self, f: F) -> Option<Self::Item>where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn min_by<F>(self, f: F) -> Option<Self::Item>where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
None
is
returned; otherwise, Some(min)
is returned. Read moresourcefn min_by_key<K, F>(self, f: F) -> Option<Self::Item>where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item>where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
None
is returned;
otherwise, Some(item)
is returned. Read moresourcefn max_by<F>(self, f: F) -> Option<Self::Item>where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn max_by<F>(self, f: F) -> Option<Self::Item>where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
None
is
returned; otherwise, Some(min)
is returned. Read moresourcefn max_by_key<K, F>(self, f: F) -> Option<Self::Item>where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item>where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
None
is returned;
otherwise, Some(item)
is returned. Read moresourcefn chain<C>(self, chain: C) -> Chain<Self, C::Iter>where
C: IntoParallelIterator<Item = Self::Item>,
fn chain<C>(self, chain: C) -> Chain<Self, C::Iter>where
C: IntoParallelIterator<Item = Self::Item>,
sourcefn find_any<P>(self, predicate: P) -> Option<Self::Item>where
P: Fn(&Self::Item) -> bool + Sync + Send,
fn find_any<P>(self, predicate: P) -> Option<Self::Item>where
P: Fn(&Self::Item) -> bool + Sync + Send,
find
on sequential iterators but
the item returned may not be the first one in the parallel
sequence which matches, since we search the entire sequence in parallel. Read moresourcefn find_first<P>(self, predicate: P) -> Option<Self::Item>where
P: Fn(&Self::Item) -> bool + Sync + Send,
fn find_first<P>(self, predicate: P) -> Option<Self::Item>where
P: Fn(&Self::Item) -> bool + Sync + Send,
sourcefn find_last<P>(self, predicate: P) -> Option<Self::Item>where
P: Fn(&Self::Item) -> bool + Sync + Send,
fn find_last<P>(self, predicate: P) -> Option<Self::Item>where
P: Fn(&Self::Item) -> bool + Sync + Send,
sourcefn find_map_any<P, R>(self, predicate: P) -> Option<R>where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn find_map_any<P, R>(self, predicate: P) -> Option<R>where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
sourcefn find_map_first<P, R>(self, predicate: P) -> Option<R>where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn find_map_first<P, R>(self, predicate: P) -> Option<R>where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
sourcefn find_map_last<P, R>(self, predicate: P) -> Option<R>where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn find_map_last<P, R>(self, predicate: P) -> Option<R>where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
sourcefn any<P>(self, predicate: P) -> boolwhere
P: Fn(Self::Item) -> bool + Sync + Send,
fn any<P>(self, predicate: P) -> boolwhere
P: Fn(Self::Item) -> bool + Sync + Send,
sourcefn all<P>(self, predicate: P) -> boolwhere
P: Fn(Self::Item) -> bool + Sync + Send,
fn all<P>(self, predicate: P) -> boolwhere
P: Fn(Self::Item) -> bool + Sync + Send,
sourcefn while_some<T>(self) -> WhileSome<Self>where
Self: ParallelIterator<Item = Option<T>>,
T: Send,
fn while_some<T>(self) -> WhileSome<Self>where
Self: ParallelIterator<Item = Option<T>>,
T: Send,
Some
items of this iterator, halting
as soon as any None
is found. Read moresourcefn panic_fuse(self) -> PanicFuse<Self>
fn panic_fuse(self) -> PanicFuse<Self>
sourcefn collect<C>(self) -> Cwhere
C: FromParallelIterator<Self::Item>,
fn collect<C>(self) -> Cwhere
C: FromParallelIterator<Self::Item>,
sourcefn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where
Self: ParallelIterator<Item = (A, B)>,
FromA: Default + Send + ParallelExtend<A>,
FromB: Default + Send + ParallelExtend<B>,
A: Send,
B: Send,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where
Self: ParallelIterator<Item = (A, B)>,
FromA: Default + Send + ParallelExtend<A>,
FromB: Default + Send + ParallelExtend<B>,
A: Send,
B: Send,
ParallelExtend
containers. Read moresourcefn partition<A, B, P>(self, predicate: P) -> (A, B)where
A: Default + Send + ParallelExtend<Self::Item>,
B: Default + Send + ParallelExtend<Self::Item>,
P: Fn(&Self::Item) -> bool + Sync + Send,
fn partition<A, B, P>(self, predicate: P) -> (A, B)where
A: Default + Send + ParallelExtend<Self::Item>,
B: Default + Send + ParallelExtend<Self::Item>,
P: Fn(&Self::Item) -> bool + Sync + Send,
ParallelExtend
containers. Items for which the predicate
returns
true go into the first container, and the rest go into the second. Read moresourcefn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B)where
A: Default + Send + ParallelExtend<L>,
B: Default + Send + ParallelExtend<R>,
P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
L: Send,
R: Send,
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B)where
A: Default + Send + ParallelExtend<L>,
B: Default + Send + ParallelExtend<R>,
P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
L: Send,
R: Send,
ParallelExtend
containers. Either::Left
items go into
the first container, and Either::Right
items go into the second. Read moresourcefn take_any(self, n: usize) -> TakeAny<Self>
fn take_any(self, n: usize) -> TakeAny<Self>
n
elements from anywhere in the original iterator. Read moresourcefn skip_any(self, n: usize) -> SkipAny<Self>
fn skip_any(self, n: usize) -> SkipAny<Self>
n
elements from anywhere in the original iterator. Read moresourcefn take_any_while<P>(self, predicate: P) -> TakeAnyWhile<Self, P>where
P: Fn(&Self::Item) -> bool + Sync + Send,
fn take_any_while<P>(self, predicate: P) -> TakeAnyWhile<Self, P>where
P: Fn(&Self::Item) -> bool + Sync + Send,
predicate
returns false
. Read moresourcefn skip_any_while<P>(self, predicate: P) -> SkipAnyWhile<Self, P>where
P: Fn(&Self::Item) -> bool + Sync + Send,
fn skip_any_while<P>(self, predicate: P) -> SkipAnyWhile<Self, P>where
P: Fn(&Self::Item) -> bool + Sync + Send,
predicate
returns false
. Read moresourceimpl<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.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, 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 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, Error>
fn seek(&mut self, pos: SeekFrom) -> Result<u64, Error>
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"
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>
fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>
fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>
fn is_write_vectored(&self) -> bool
fn is_write_vectored(&self) -> bool
fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>
fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>
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
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstablefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
impl<F> IntoFuture for Fwhere
F: Future,
impl<F> IntoFuture for Fwhere
F: Future,
type Output = <F as Future>::Output
type Output = <F as Future>::Output
type IntoFuture = F
type IntoFuture = F
fn into_future(self) -> <F as IntoFuture>::IntoFuture
fn into_future(self) -> <F as IntoFuture>::IntoFuture
sourceimpl<T> IntoParallelIterator for Twhere
T: ParallelIterator,
impl<T> IntoParallelIterator for Twhere
T: ParallelIterator,
type Iter = T
type Iter = T
type Item = <T as ParallelIterator>::Item
type Item = <T as ParallelIterator>::Item
sourcefn into_par_iter(self) -> T
fn into_par_iter(self) -> T
self
into a parallel iterator. Read more