Enum astral::thirdparty::rayon::iter::Either
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> ⓘ
pub fn as_ref(&self) -> Either<&L, &R> ⓘ
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> ⓘ
pub fn as_mut(&mut self) -> Either<&mut L, &mut R> ⓘ
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>> ⓘ
pub fn as_pin_ref(self: Pin<&Either<L, R>>) -> Either<Pin<&L>, Pin<&R>> ⓘ
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>> ⓘ
pub fn as_pin_mut(
self: Pin<&mut Either<L, R>>
) -> Either<Pin<&mut L>, Pin<&mut R>> ⓘ
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> ⓘ
pub fn flip(self) -> Either<R, L> ⓘ
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> ⓘwhere
F: FnOnce(L) -> M,
pub fn map_left<F, M>(self, f: F) -> Either<M, R> ⓘwhere
F: FnOnce(L) -> M,
Apply the function f
on the value in the Left
variant if it is present rewrapping the
result in Left
.
use either::*;
let left: Either<_, u32> = Left(123);
assert_eq!(left.map_left(|x| x * 2), Left(246));
let right: Either<u32, _> = Right(123);
assert_eq!(right.map_left(|x| x * 2), Right(123));
sourcepub fn map_right<F, S>(self, f: F) -> Either<L, S> ⓘwhere
F: FnOnce(R) -> S,
pub fn map_right<F, S>(self, f: F) -> Either<L, S> ⓘwhere
F: FnOnce(R) -> S,
Apply the function f
on the value in the Right
variant if it is present rewrapping the
result in Right
.
use either::*;
let left: Either<_, u32> = Left(123);
assert_eq!(left.map_right(|x| x * 2), Left(123));
let right: Either<u32, _> = Right(123);
assert_eq!(right.map_right(|x| x * 2), Right(246));
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> ⓘwhere
F: FnOnce(L) -> Either<S, R>,
pub fn left_and_then<F, S>(self, f: F) -> Either<S, R> ⓘwhere
F: FnOnce(L) -> Either<S, R>,
Apply the function f
on the value in the Left
variant if it is present.
use either::*;
let left: Either<_, u32> = Left(123);
assert_eq!(left.left_and_then::<_,()>(|x| Right(x * 2)), Right(246));
let right: Either<u32, _> = Right(123);
assert_eq!(right.left_and_then(|x| Right::<(), _>(x * 2)), Right(123));
sourcepub fn right_and_then<F, S>(self, f: F) -> Either<L, S> ⓘwhere
F: FnOnce(R) -> Either<L, S>,
pub fn right_and_then<F, S>(self, f: F) -> Either<L, S> ⓘwhere
F: FnOnce(R) -> Either<L, S>,
Apply the function f
on the value in the Right
variant if it is present.
use either::*;
let left: Either<_, u32> = Left(123);
assert_eq!(left.right_and_then(|x| Right(x * 2)), Left(123));
let right: Either<u32, _> = Right(123);
assert_eq!(right.right_and_then(|x| Right(x * 2)), Right(246));
sourcepub fn into_iter(
self
) -> Either<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter> ⓘwhere
L: IntoIterator,
R: IntoIterator<Item = <L as IntoIterator>::Item>,
pub fn into_iter(
self
) -> Either<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter> ⓘwhere
L: IntoIterator,
R: IntoIterator<Item = <L as IntoIterator>::Item>,
Convert the inner value to an iterator.
use either::*;
let left: Either<_, Vec<u32>> = Left(vec![1, 2, 3, 4, 5]);
let mut right: Either<Vec<u32>, _> = Right(vec![]);
right.extend(left.into_iter());
assert_eq!(right, Right(vec![1, 2, 3, 4, 5]));
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);
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, 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> 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>,
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> 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
.
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>,
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>,
fn from_par_iter<I>(pi: I) -> (A, B)where
I: IntoParallelIterator<Item = Either<L, R>>,
fn from_par_iter<I>(pi: I) -> (A, B)where
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.
impl<L, R> IndexedParallelIterator for Either<L, R>where
L: IndexedParallelIterator,
R: IndexedParallelIterator<Item = <L as ParallelIterator>::Item>,
impl<L, R> IndexedParallelIterator for Either<L, R>where
L: IndexedParallelIterator,
R: IndexedParallelIterator<Item = <L as ParallelIterator>::Item>,
fn drive<C>(
self,
consumer: C
) -> <C as Consumer<<Either<L, R> as ParallelIterator>::Item>>::Resultwhere
C: Consumer<<Either<L, R> as ParallelIterator>::Item>,
fn drive<C>(
self,
consumer: C
) -> <C as Consumer<<Either<L, R> as ParallelIterator>::Item>>::Resultwhere
C: Consumer<<Either<L, R> as ParallelIterator>::Item>,
fn len(&self) -> usize
fn len(&self) -> usize
fn with_producer<CB>(
self,
callback: CB
) -> <CB as ProducerCallback<<Either<L, R> as ParallelIterator>::Item>>::Outputwhere
CB: ProducerCallback<<Either<L, R> as ParallelIterator>::Item>,
fn with_producer<CB>(
self,
callback: CB
) -> <CB as ProducerCallback<<Either<L, R> as ParallelIterator>::Item>>::Outputwhere
CB: ProducerCallback<<Either<L, R> as ParallelIterator>::Item>,
fn collect_into_vec(self, target: &mut Vec<Self::Item, Global>)
fn collect_into_vec(self, target: &mut Vec<Self::Item, Global>)
fn unzip_into_vecs<A, B>(
self,
left: &mut Vec<A, Global>,
right: &mut Vec<B, Global>
)where
Self: IndexedParallelIterator<Item = (A, B)>,
A: Send,
B: Send,
fn unzip_into_vecs<A, B>(
self,
left: &mut Vec<A, Global>,
right: &mut Vec<B, Global>
)where
Self: IndexedParallelIterator<Item = (A, B)>,
A: Send,
B: Send,
fn zip<Z>(self, zip_op: Z) -> Zip<Self, <Z as IntoParallelIterator>::Iter>where
Z: IntoParallelIterator,
<Z as IntoParallelIterator>::Iter: IndexedParallelIterator,
fn zip<Z>(self, zip_op: Z) -> Zip<Self, <Z as IntoParallelIterator>::Iter>where
Z: IntoParallelIterator,
<Z as IntoParallelIterator>::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 morefn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, <Z as IntoParallelIterator>::Iter>where
Z: IntoParallelIterator,
<Z as IntoParallelIterator>::Iter: IndexedParallelIterator,
fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, <Z as IntoParallelIterator>::Iter>where
Z: IntoParallelIterator,
<Z as IntoParallelIterator>::Iter: IndexedParallelIterator,
Zip
, but requires that both iterators have the same length. Read morefn interleave<I>(
self,
other: I
) -> Interleave<Self, <I as IntoParallelIterator>::Iter>where
I: IntoParallelIterator<Item = Self::Item>,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator<Item = Self::Item>,
fn interleave<I>(
self,
other: I
) -> Interleave<Self, <I as IntoParallelIterator>::Iter>where
I: IntoParallelIterator<Item = Self::Item>,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator<Item = Self::Item>,
fn interleave_shortest<I>(
self,
other: I
) -> InterleaveShortest<Self, <I as IntoParallelIterator>::Iter>where
I: IntoParallelIterator<Item = Self::Item>,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator<Item = Self::Item>,
fn interleave_shortest<I>(
self,
other: I
) -> InterleaveShortest<Self, <I as IntoParallelIterator>::Iter>where
I: IntoParallelIterator<Item = Self::Item>,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator<Item = Self::Item>,
fn chunks(self, chunk_size: usize) -> Chunks<Self>
fn chunks(self, chunk_size: usize) -> Chunks<Self>
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,
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,
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,
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,
fn partial_cmp<I>(self, other: I) -> Option<Ordering>where
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,
fn partial_cmp<I>(self, other: I) -> Option<Ordering>where
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,
ParallelIterator
with those of
another. Read morefn eq<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialEq<<I as IntoParallelIterator>::Item>,
fn eq<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialEq<<I as IntoParallelIterator>::Item>,
ParallelIterator
are equal to those of another Read morefn ne<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialEq<<I as IntoParallelIterator>::Item>,
fn ne<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialEq<<I as IntoParallelIterator>::Item>,
ParallelIterator
are unequal to those of another Read morefn lt<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,
fn lt<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,
ParallelIterator
are lexicographically less than those of another. Read morefn le<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,
fn le<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,
ParallelIterator
are less or equal to those of another. Read morefn gt<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,
fn gt<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,
ParallelIterator
are lexicographically greater than those of another. Read morefn ge<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,
fn ge<I>(self, other: I) -> boolwhere
I: IntoParallelIterator,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<<I as IntoParallelIterator>::Item>,
ParallelIterator
are less or equal to those of another. Read morefn step_by(self, step: usize) -> StepBy<Self>
fn step_by(self, step: usize) -> StepBy<Self>
fn take(self, n: usize) -> Take<Self>
fn take(self, n: usize) -> Take<Self>
n
elements. Read morefn 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 morefn 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,
fn 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,
fn 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,
fn rev(self) -> Rev<Self>
fn rev(self) -> Rev<Self>
fn with_min_len(self, min: usize) -> MinLen<Self>
fn with_min_len(self, min: usize) -> MinLen<Self>
fn 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.
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>>where
Self: Sized,
fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
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>where
Self: Sized,
fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
1.0.0 · sourcefn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator<Item = Self::Item>,
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator<Item = Self::Item>,
1.0.0 · sourcefn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
sourcefn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>where
Self: Sized,
G: FnMut() -> Self::Item,
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>where
Self: Sized,
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
Self: Sized,
F: FnMut(Self::Item) -> B,
fn map<B, F>(self, f: F) -> Map<Self, F>where
Self: Sized,
F: FnMut(Self::Item) -> B,
1.0.0 · sourcefn filter<P>(self, predicate: P) -> Filter<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn filter<P>(self, predicate: P) -> Filter<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
1.0.0 · sourcefn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
1.0.0 · sourcefn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
1.0.0 · sourcefn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
1.0.0 · sourcefn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
1.57.0 · sourcefn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>where
Self: Sized,
P: FnMut(Self::Item) -> Option<B>,
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>where
Self: Sized,
P: FnMut(Self::Item) -> Option<B>,
1.0.0 · sourcefn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
n
elements. Read more1.0.0 · sourcefn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where
Self: Sized,
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
Self: Sized,
F: FnMut(&mut St, Self::Item) -> Option<B>,
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where
Self: Sized,
F: FnMut(&mut St, Self::Item) -> Option<B>,
1.0.0 · sourcefn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where
Self: Sized,
U: IntoIterator,
F: FnMut(Self::Item) -> U,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where
Self: Sized,
U: IntoIterator,
F: FnMut(Self::Item) -> U,
1.0.0 · sourcefn inspect<F>(self, f: F) -> Inspect<Self, F>where
Self: Sized,
F: FnMut(&Self::Item),
fn inspect<F>(self, f: F) -> Inspect<Self, F>where
Self: Sized,
F: FnMut(&Self::Item),
1.0.0 · sourcefn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
sourcefn collect_into<E>(self, collection: &mut E) -> &mut Ewhere
E: Extend<Self::Item>,
Self: Sized,
fn collect_into<E>(self, collection: &mut E) -> &mut Ewhere
E: Extend<Self::Item>,
Self: Sized,
iter_collect_into
)sourcefn is_partitioned<P>(self, predicate: P) -> boolwhere
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn is_partitioned<P>(self, predicate: P) -> boolwhere
Self: Sized,
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
Self: Sized,
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere
Self: Sized,
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
1.27.0 · sourcefn try_for_each<F, R>(&mut self, f: F) -> Rwhere
Self: Sized,
F: FnMut(Self::Item) -> R,
R: Try<Output = ()>,
fn try_for_each<F, R>(&mut self, f: F) -> Rwhere
Self: Sized,
F: FnMut(Self::Item) -> R,
R: Try<Output = ()>,
1.51.0 · sourcefn reduce<F>(self, f: F) -> Option<Self::Item>where
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> Self::Item,
fn reduce<F>(self, f: F) -> Option<Self::Item>where
Self: Sized,
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
Self: Sized,
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
Self: Sized,
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
Self: Sized,
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
Self: Sized,
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,
Self: Sized,
F: FnMut(&Self::Item) -> B,
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
Self: Sized,
F: FnMut(&Self::Item) -> B,
1.15.0 · sourcefn max_by<F>(self, compare: F) -> Option<Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn max_by<F>(self, compare: F) -> Option<Self::Item>where
Self: Sized,
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,
Self: Sized,
F: FnMut(&Self::Item) -> B,
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
Self: Sized,
F: FnMut(&Self::Item) -> B,
1.15.0 · sourcefn min_by<F>(self, compare: F) -> Option<Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_by<F>(self, compare: F) -> Option<Self::Item>where
Self: Sized,
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: Sized + Iterator<Item = (A, B)>,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Sized + Iterator<Item = (A, B)>,
1.36.0 · sourcefn copied<'a, T>(self) -> Copied<Self>where
T: 'a + Copy,
Self: Sized + Iterator<Item = &'a T>,
fn copied<'a, T>(self) -> Copied<Self>where
T: 'a + Copy,
Self: Sized + Iterator<Item = &'a T>,
1.0.0 · sourcefn cloned<'a, T>(self) -> Cloned<Self>where
T: 'a + Clone,
Self: Sized + Iterator<Item = &'a T>,
fn cloned<'a, T>(self) -> Cloned<Self>where
T: 'a + Clone,
Self: Sized + Iterator<Item = &'a T>,
sourcefn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
iter_array_chunks
)N
elements of the iterator at a time. Read more1.11.0 · sourcefn sum<S>(self) -> Swhere
Self: Sized,
S: Sum<Self::Item>,
fn sum<S>(self) -> Swhere
Self: Sized,
S: Sum<Self::Item>,
1.11.0 · sourcefn product<P>(self) -> Pwhere
Self: Sized,
P: Product<Self::Item>,
fn product<P>(self) -> Pwhere
Self: Sized,
P: Product<Self::Item>,
sourcefn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
fn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere
Self: Sized,
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>,
Self: Sized,
fn partial_cmp<I>(self, other: I) -> Option<Ordering>where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
sourcefn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
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
Self: Sized,
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>,
Self: Sized,
fn eq<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
Self: Sized,
sourcefn eq_by<I, F>(self, other: I, eq: F) -> boolwhere
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
fn eq_by<I, F>(self, other: I, eq: F) -> boolwhere
Self: Sized,
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>,
Self: Sized,
fn ne<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
Self: Sized,
1.5.0 · sourcefn lt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn lt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
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>,
Self: Sized,
fn le<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
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>,
Self: Sized,
fn gt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
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>,
Self: Sized,
fn ge<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
Iterator
are lexicographically
greater than or equal to those of another. Read moresourcefn is_sorted_by<F>(self, compare: F) -> boolwhere
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
fn is_sorted_by<F>(self, compare: F) -> boolwhere
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
is_sorted
)sourcefn is_sorted_by_key<F, K>(self, f: F) -> boolwhere
Self: Sized,
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
fn is_sorted_by_key<F, K>(self, f: F) -> boolwhere
Self: Sized,
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) -> Selfwhere
Self: Sized,
fn max(self, other: Self) -> Selfwhere
Self: Sized,
1.21.0 · sourcefn min(self, other: Self) -> Selfwhere
Self: Sized,
fn min(self, other: Self) -> Selfwhere
Self: Sized,
1.50.0 · sourcefn clamp(self, min: Self, max: Self) -> Selfwhere
Self: Sized + PartialOrd<Self>,
fn clamp(self, min: Self, max: Self) -> Selfwhere
Self: Sized + PartialOrd<Self>,
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>,
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>,
fn 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 moreimpl<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.
fn 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 moreimpl<L, R> ParallelIterator for Either<L, R>where
L: ParallelIterator,
R: ParallelIterator<Item = <L as ParallelIterator>::Item>,
impl<L, R> ParallelIterator for Either<L, R>where
L: ParallelIterator,
R: ParallelIterator<Item = <L as ParallelIterator>::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
fn drive_unindexed<C>(
self,
consumer: C
) -> <C as Consumer<<Either<L, R> as ParallelIterator>::Item>>::Resultwhere
C: UnindexedConsumer<<Either<L, R> as ParallelIterator>::Item>,
fn drive_unindexed<C>(
self,
consumer: C
) -> <C as Consumer<<Either<L, R> as ParallelIterator>::Item>>::Resultwhere
C: UnindexedConsumer<<Either<L, R> as ParallelIterator>::Item>,
fn opt_len(&self) -> Option<usize>
fn opt_len(&self) -> Option<usize>
fn 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 morefn 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,
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,
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 morefn 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 morefn 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 morefn 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 morefn 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 morefn 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 morefn 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 morefn 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>,
fn 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>,
fn 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 morefn 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,
fn 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 morefn 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 morefn 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 morefn flat_map_iter<F, SI>(self, map_op: F) -> FlatMapIter<Self, F>where
F: Fn(Self::Item) -> SI + Sync + Send,
SI: IntoIterator,
<SI as IntoIterator>::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 as IntoIterator>::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 morefn 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 morefn 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 morefn 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 morefn 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 morefn 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,
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,
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 morefn sum<S>(self) -> Swhere
S: Send + Sum<Self::Item> + Sum<S>,
fn sum<S>(self) -> Swhere
S: Send + Sum<Self::Item> + Sum<S>,
fn product<P>(self) -> Pwhere
P: Send + Product<Self::Item> + Product<P>,
fn product<P>(self) -> Pwhere
P: Send + Product<Self::Item> + Product<P>,
fn 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 morefn 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 morefn 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 morefn 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 morefn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter>where
C: IntoParallelIterator<Item = Self::Item>,
fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter>where
C: IntoParallelIterator<Item = Self::Item>,
fn 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 morefn 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,
fn 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,
fn 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,
fn 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,
fn 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,
fn 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,
fn 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,
fn 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 morefn panic_fuse(self) -> PanicFuse<Self>
fn panic_fuse(self) -> PanicFuse<Self>
fn collect<C>(self) -> Cwhere
C: FromParallelIterator<Self::Item>,
fn collect<C>(self) -> Cwhere
C: FromParallelIterator<Self::Item>,
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,
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 morefn 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 morefn 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 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.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moreimpl<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<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,
impl<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
fn into_par_iter(self) -> T
fn into_par_iter(self) -> T
self
into a parallel iterator. Read more