Enum rayon::iter::Either [−][src]
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
Expand description
A value of type L
.
Expand description
A value of type R
.
Implementations
impl<L, R> Either<L, R>
[src]
impl<L, R> Either<L, R>
[src]pub fn is_left(&self) -> bool
[src]
pub fn is_left(&self) -> bool
[src]Return true if the value is the Left
variant.
use either::*; let values = [Left(1), Right("the right value")]; assert_eq!(values[0].is_left(), true); assert_eq!(values[1].is_left(), false);
pub fn is_right(&self) -> bool
[src]
pub fn is_right(&self) -> bool
[src]Return true if the value is the Right
variant.
use either::*; let values = [Left(1), Right("the right value")]; assert_eq!(values[0].is_right(), false); assert_eq!(values[1].is_right(), true);
pub fn left(self) -> Option<L>
[src]
pub fn left(self) -> Option<L>
[src]Convert the left side of Either<L, R>
to an Option<L>
.
use either::*; let left: Either<_, ()> = Left("some value"); assert_eq!(left.left(), Some("some value")); let right: Either<(), _> = Right(321); assert_eq!(right.left(), None);
pub fn right(self) -> Option<R>
[src]
pub fn right(self) -> Option<R>
[src]Convert the right side of Either<L, R>
to an Option<R>
.
use either::*; let left: Either<_, ()> = Left("some value"); assert_eq!(left.right(), None); let right: Either<(), _> = Right(321); assert_eq!(right.right(), Some(321));
pub fn as_ref(&self) -> Either<&L, &R>ⓘ
[src]
pub fn as_ref(&self) -> Either<&L, &R>ⓘ
[src]Convert &Either<L, R>
to Either<&L, &R>
.
use either::*; let left: Either<_, ()> = Left("some value"); assert_eq!(left.as_ref(), Left(&"some value")); let right: Either<(), _> = Right("some value"); assert_eq!(right.as_ref(), Right(&"some value"));
pub fn as_mut(&mut self) -> Either<&mut L, &mut R>ⓘ
[src]
pub fn as_mut(&mut self) -> Either<&mut L, &mut R>ⓘ
[src]Convert &mut Either<L, R>
to Either<&mut L, &mut R>
.
use either::*; fn mutate_left(value: &mut Either<u32, u32>) { if let Some(l) = value.as_mut().left() { *l = 999; } } let mut left = Left(123); let mut right = Right(123); mutate_left(&mut left); mutate_left(&mut right); assert_eq!(left, Left(999)); assert_eq!(right, Right(123));
pub fn flip(self) -> Either<R, L>ⓘ
[src]
pub fn flip(self) -> Either<R, L>ⓘ
[src]Convert Either<L, R>
to Either<R, L>
.
use either::*; let left: Either<_, ()> = Left(123); assert_eq!(left.flip(), Right(123)); let right: Either<(), _> = Right("some value"); assert_eq!(right.flip(), Left("some value"));
pub fn map_left<F, M>(self, f: F) -> Either<M, R>ⓘ where
F: FnOnce(L) -> M,
[src]
pub fn map_left<F, M>(self, f: F) -> Either<M, R>ⓘ where
F: FnOnce(L) -> M,
[src]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));
pub fn map_right<F, S>(self, f: F) -> Either<L, S>ⓘ where
F: FnOnce(R) -> S,
[src]
pub fn map_right<F, S>(self, f: F) -> Either<L, S>ⓘ where
F: FnOnce(R) -> S,
[src]Apply the function f
on the value in the Right
variant if it is present rewrapping the
result in Right
.
use either::*; let left: Either<_, u32> = Left(123); assert_eq!(left.map_right(|x| x * 2), Left(123)); let right: Either<u32, _> = Right(123); assert_eq!(right.map_right(|x| x * 2), Right(246));
pub fn either<F, G, T>(self, f: F, g: G) -> T where
F: FnOnce(L) -> T,
G: FnOnce(R) -> T,
[src]
pub fn either<F, G, T>(self, f: F, g: G) -> T where
F: FnOnce(L) -> T,
G: FnOnce(R) -> T,
[src]Apply one of two functions depending on contents, unifying their result. If the value is
Left(L)
then the first function f
is applied; if it is Right(R)
then the second
function g
is applied.
use either::*; fn square(n: u32) -> i32 { (n * n) as i32 } fn negate(n: i32) -> i32 { -n } let left: Either<u32, i32> = Left(4); assert_eq!(left.either(square, negate), 16); let right: Either<u32, i32> = Right(-4); assert_eq!(right.either(square, negate), 4);
pub fn either_with<Ctx, F, G, T>(self, ctx: Ctx, f: F, g: G) -> T where
F: FnOnce(Ctx, L) -> T,
G: FnOnce(Ctx, R) -> T,
[src]
pub fn either_with<Ctx, F, G, T>(self, ctx: Ctx, f: F, g: G) -> T where
F: FnOnce(Ctx, L) -> T,
G: FnOnce(Ctx, R) -> T,
[src]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]);
pub fn left_and_then<F, S>(self, f: F) -> Either<S, R>ⓘ where
F: FnOnce(L) -> Either<S, R>,
[src]
pub fn left_and_then<F, S>(self, f: F) -> Either<S, R>ⓘ where
F: FnOnce(L) -> Either<S, R>,
[src]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));
pub fn right_and_then<F, S>(self, f: F) -> Either<L, S>ⓘ where
F: FnOnce(R) -> Either<L, S>,
[src]
pub fn right_and_then<F, S>(self, f: F) -> Either<L, S>ⓘ where
F: FnOnce(R) -> Either<L, S>,
[src]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));
pub fn into_iter(
self
) -> Either<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter>ⓘ where
R: IntoIterator<Item = <L as IntoIterator>::Item>,
L: IntoIterator,
[src]
pub fn into_iter(
self
) -> Either<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter>ⓘ where
R: IntoIterator<Item = <L as IntoIterator>::Item>,
L: IntoIterator,
[src]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]));
pub fn left_or(self, other: L) -> L
[src]
pub fn left_or(self, other: L) -> L
[src]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");
pub fn left_or_default(self) -> L where
L: Default,
[src]
pub fn left_or_default(self) -> L where
L: Default,
[src]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());
pub fn left_or_else<F>(self, f: F) -> L where
F: FnOnce(R) -> L,
[src]
pub fn left_or_else<F>(self, f: F) -> L where
F: FnOnce(R) -> L,
[src]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");
pub fn right_or(self, other: R) -> R
[src]
pub fn right_or(self, other: R) -> R
[src]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");
pub fn right_or_default(self) -> R where
R: Default,
[src]
pub fn right_or_default(self) -> R where
R: Default,
[src]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);
pub fn right_or_else<F>(self, f: F) -> R where
F: FnOnce(L) -> R,
[src]
pub fn right_or_else<F>(self, f: F) -> R where
F: FnOnce(L) -> R,
[src]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);
pub fn unwrap_left(self) -> L where
R: Debug,
[src]
pub fn unwrap_left(self) -> L where
R: Debug,
[src]pub fn unwrap_right(self) -> R where
L: Debug,
[src]
pub fn unwrap_right(self) -> R where
L: Debug,
[src]pub fn expect_left(self, msg: &str) -> L where
R: Debug,
[src]
pub fn expect_left(self, msg: &str) -> L where
R: Debug,
[src]impl<T, L, R> Either<(T, L), (T, R)>
[src]
impl<T, L, R> Either<(T, L), (T, R)>
[src]pub fn factor_first(self) -> (T, Either<L, R>)
[src]
pub fn factor_first(self) -> (T, Either<L, R>)
[src]Factor out a homogeneous type from an either of pairs.
Here, the homogeneous type is the first element of the pairs.
use either::*; let left: Either<_, (u32, String)> = Left((123, vec![0])); assert_eq!(left.factor_first().0, 123); let right: Either<(u32, Vec<u8>), _> = Right((123, String::new())); assert_eq!(right.factor_first().0, 123);
impl<T, L, R> Either<(L, T), (R, T)>
[src]
impl<T, L, R> Either<(L, T), (R, T)>
[src]pub fn factor_second(self) -> (Either<L, R>, T)
[src]
pub fn factor_second(self) -> (Either<L, R>, T)
[src]Factor out a homogeneous type from an either of pairs.
Here, the homogeneous type is the second element of the pairs.
use either::*; let left: Either<_, (String, u32)> = Left((vec![0], 123)); assert_eq!(left.factor_second().1, 123); let right: Either<(Vec<u8>, u32), _> = Right((String::new(), 123)); assert_eq!(right.factor_second().1, 123);
impl<T> Either<T, T>
[src]
impl<T> Either<T, T>
[src]pub fn into_inner(self) -> T
[src]
pub fn into_inner(self) -> T
[src]Extract the value of an either over two equivalent types.
use either::*; let left: Either<_, u32> = Left(123); assert_eq!(left.into_inner(), 123); let right: Either<u32, _> = Right(123); assert_eq!(right.into_inner(), 123);
Trait Implementations
impl<L, R, Target> AsMut<[Target]> for Either<L, R> where
R: AsMut<[Target]>,
L: AsMut<[Target]>,
[src]
impl<L, R, Target> AsMut<[Target]> for Either<L, R> where
R: AsMut<[Target]>,
L: AsMut<[Target]>,
[src]pub fn as_mut(&mut self) -> &mut [Target]
[src]
pub fn as_mut(&mut self) -> &mut [Target]
[src]Performs the conversion.
impl<L, R, Target> AsRef<[Target]> for Either<L, R> where
R: AsRef<[Target]>,
L: AsRef<[Target]>,
[src]
impl<L, R, Target> AsRef<[Target]> for Either<L, R> where
R: AsRef<[Target]>,
L: AsRef<[Target]>,
[src]impl<L, R> Clone for Either<L, R> where
R: Clone,
L: Clone,
[src]
impl<L, R> Clone for Either<L, R> where
R: Clone,
L: Clone,
[src]impl<L, R> DerefMut for Either<L, R> where
R: DerefMut<Target = <L as Deref>::Target>,
L: DerefMut,
[src]
impl<L, R> DerefMut for Either<L, R> where
R: DerefMut<Target = <L as Deref>::Target>,
L: DerefMut,
[src]impl<L, R> DoubleEndedIterator for Either<L, R> where
R: DoubleEndedIterator<Item = <L as Iterator>::Item>,
L: DoubleEndedIterator,
[src]
impl<L, R> DoubleEndedIterator for Either<L, R> where
R: DoubleEndedIterator<Item = <L as Iterator>::Item>,
L: DoubleEndedIterator,
[src]pub fn next_back(&mut self) -> Option<<Either<L, R> as Iterator>::Item>
[src]
pub fn next_back(&mut self) -> Option<<Either<L, R> as Iterator>::Item>
[src]Removes and returns an element from the end of the iterator. Read more
fn advance_back_by(&mut self, n: usize) -> Result<(), usize>
[src]
fn advance_back_by(&mut self, n: usize) -> Result<(), usize>
[src]🔬 This is a nightly-only experimental API. (iter_advance_by
)
recently added
Advances the iterator from the back by n
elements. Read more
fn nth_back(&mut self, n: usize) -> Option<Self::Item>
1.37.0[src]
fn nth_back(&mut self, n: usize) -> Option<Self::Item>
1.37.0[src]Returns the n
th element from the end of the iterator. Read more
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
1.27.0[src]
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
1.27.0[src]This is the reverse version of Iterator::try_fold()
: it takes
elements starting from the back of the iterator. Read more
impl<L, R> ExactSizeIterator for Either<L, R> where
R: ExactSizeIterator<Item = <L as Iterator>::Item>,
L: ExactSizeIterator,
[src]
impl<L, R> ExactSizeIterator for Either<L, R> where
R: ExactSizeIterator<Item = <L as Iterator>::Item>,
L: ExactSizeIterator,
[src]impl<L, R, A> Extend<A> for Either<L, R> where
R: Extend<A>,
L: Extend<A>,
[src]
impl<L, R, A> Extend<A> for Either<L, R> where
R: Extend<A>,
L: Extend<A>,
[src]pub fn extend<T>(&mut self, iter: T) where
T: IntoIterator<Item = A>,
[src]
pub fn extend<T>(&mut self, iter: T) where
T: IntoIterator<Item = A>,
[src]Extends a collection with the contents of an iterator. Read more
fn extend_one(&mut self, item: A)
[src]
fn extend_one(&mut self, item: A)
[src]extend_one
)Extends a collection with exactly one element.
fn extend_reserve(&mut self, additional: usize)
[src]
fn extend_reserve(&mut self, additional: usize)
[src]extend_one
)Reserves capacity in a collection for the given number of additional elements. Read more
impl<L, R> From<Result<R, L>> for Either<L, R>
[src]
impl<L, R> From<Result<R, L>> for Either<L, R>
[src]Convert from Result
to Either
with Ok => Right
and Err => Left
.
impl<L, R, A, B> FromParallelIterator<Either<L, R>> for (A, B) where
L: Send,
R: Send,
A: Send + FromParallelIterator<L>,
B: Send + FromParallelIterator<R>,
[src]
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>,
[src]fn from_par_iter<I>(pi: I) -> Self where
I: IntoParallelIterator<Item = Either<L, R>>,
[src]
fn from_par_iter<I>(pi: I) -> Self where
I: IntoParallelIterator<Item = Either<L, R>>,
[src]Creates an instance of the collection from the parallel iterator par_iter
. Read more
impl<L, R> IndexedParallelIterator for Either<L, R> where
L: IndexedParallelIterator,
R: IndexedParallelIterator<Item = L::Item>,
[src]
impl<L, R> IndexedParallelIterator for Either<L, R> where
L: IndexedParallelIterator,
R: IndexedParallelIterator<Item = L::Item>,
[src]fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]Internal method used to define the behavior of this parallel iterator. You should not need to call this directly. Read more
fn len(&self) -> usize
[src]
fn len(&self) -> usize
[src]Produces an exact count of how many items this iterator will produce, presuming no panic occurs. Read more
fn with_producer<CB>(self, callback: CB) -> CB::Output where
CB: ProducerCallback<Self::Item>,
[src]
fn with_producer<CB>(self, callback: CB) -> CB::Output where
CB: ProducerCallback<Self::Item>,
[src]Internal method used to define the behavior of this parallel iterator. You should not need to call this directly. Read more
fn collect_into_vec(self, target: &mut Vec<Self::Item>)
[src]
fn collect_into_vec(self, target: &mut Vec<Self::Item>)
[src]Collects the results of the iterator into the specified vector. The vector is always truncated before execution begins. If possible, reusing the vector across calls can lead to better performance since it reuses the same backing buffer. Read more
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,
[src]
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,
[src]Unzips the results of the iterator into the specified vectors. The vectors are always truncated before execution begins. If possible, reusing the vectors across calls can lead to better performance since they reuse the same backing buffer. Read more
fn zip<Z>(self, zip_op: Z) -> Zip<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
fn zip<Z>(self, zip_op: Z) -> Zip<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]Iterates over tuples (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 more
fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]The same as Zip
, but requires that both iterators have the same length. Read more
fn interleave<I>(self, other: I) -> Interleave<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
fn interleave<I>(self, other: I) -> Interleave<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]Interleaves elements of this iterator and the other given iterator. Alternately yields elements from this iterator and the given iterator, until both are exhausted. If one iterator is exhausted before the other, the last elements are provided from the other. Read more
fn interleave_shortest<I>(self, other: I) -> InterleaveShortest<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
fn interleave_shortest<I>(self, other: I) -> InterleaveShortest<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]Interleaves elements of this iterator and the other given iterator, until one is exhausted. Read more
fn chunks(self, chunk_size: usize) -> Chunks<Self>
[src]
fn chunks(self, chunk_size: usize) -> Chunks<Self>
[src]Splits an iterator up into fixed-size chunks. Read more
fn cmp<I>(self, other: I) -> Ordering where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
[src]
fn cmp<I>(self, other: I) -> Ordering where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
[src]Lexicographically compares the elements of this ParallelIterator
with those of
another. Read more
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]Lexicographically compares the elements of this ParallelIterator
with those of
another. Read more
fn eq<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
fn eq<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]Determines if the elements of this ParallelIterator
are equal to those of another Read more
fn ne<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
fn ne<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]Determines if the elements of this ParallelIterator
are unequal to those of another Read more
fn lt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
fn lt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]Determines if the elements of this ParallelIterator
are lexicographically less than those of another. Read more
fn le<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
fn le<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]Determines if the elements of this ParallelIterator
are less or equal to those of another. Read more
fn gt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
fn gt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]Determines if the elements of this ParallelIterator
are lexicographically greater than those of another. Read more
fn ge<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
fn ge<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]Determines if the elements of this ParallelIterator
are less or equal to those of another. Read more
fn step_by(self, step: usize) -> StepBy<Self>
[src]
fn step_by(self, step: usize) -> StepBy<Self>
[src]Creates an iterator that steps by the given amount Read more
fn skip(self, n: usize) -> Skip<Self>
[src]
fn skip(self, n: usize) -> Skip<Self>
[src]Creates an iterator that skips the first n
elements. Read more
fn take(self, n: usize) -> Take<Self>
[src]
fn take(self, n: usize) -> Take<Self>
[src]Creates an iterator that yields the first n
elements. Read more
fn position_any<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
fn position_any<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]Searches for some item in the parallel iterator that
matches the given predicate, and returns its index. Like
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 more
fn position_first<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
fn position_first<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]Searches for the sequentially first item in the parallel iterator that matches the given predicate, and returns its index. Read more
fn position_last<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
fn position_last<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]Searches for the sequentially last item in the parallel iterator that matches the given predicate, and returns its index. Read more
fn positions<P>(self, predicate: P) -> Positions<Self, P> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
fn positions<P>(self, predicate: P) -> Positions<Self, P> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]Searches for items in the parallel iterator that match the given predicate, and returns their indices. Read more
fn rev(self) -> Rev<Self>
[src]
fn rev(self) -> Rev<Self>
[src]Produces a new iterator with the elements of this iterator in reverse order. Read more
fn with_min_len(self, min: usize) -> MinLen<Self>
[src]
fn with_min_len(self, min: usize) -> MinLen<Self>
[src]Sets the minimum length of iterators desired to process in each thread. Rayon will not split any smaller than this length, but of course an iterator could already be smaller to begin with. Read more
fn with_max_len(self, max: usize) -> MaxLen<Self>
[src]
fn with_max_len(self, max: usize) -> MaxLen<Self>
[src]Sets the maximum length of iterators desired to process in each
thread. Rayon will try to split at least below this length,
unless that would put it below the length from with_min_len()
.
For example, given min=10 and max=15, a length of 16 will not be
split any further. Read more
impl<L, R> Into<Result<R, L>> for Either<L, R>
[src]
impl<L, R> Into<Result<R, L>> for Either<L, R>
[src]Convert from Either
to Result
with Right => Ok
and Left => Err
.
impl<L, R> Iterator for Either<L, R> where
R: Iterator<Item = <L as Iterator>::Item>,
L: Iterator,
[src]
impl<L, R> Iterator for Either<L, R> where
R: Iterator<Item = <L as Iterator>::Item>,
L: Iterator,
[src]Either<L, R>
is an iterator if both L
and R
are iterators.
pub fn next(&mut self) -> Option<<Either<L, R> as Iterator>::Item>
[src]
pub fn next(&mut self) -> Option<<Either<L, R> as Iterator>::Item>
[src]Advances the iterator and returns the next value. Read more
pub fn size_hint(&self) -> (usize, Option<usize>)
[src]
pub fn size_hint(&self) -> (usize, Option<usize>)
[src]Returns the bounds on the remaining length of the iterator. Read more
pub fn fold<Acc, G>(self, init: Acc, f: G) -> Acc where
G: FnMut(Acc, <Either<L, R> as Iterator>::Item) -> Acc,
[src]
pub fn fold<Acc, G>(self, init: Acc, f: G) -> Acc where
G: FnMut(Acc, <Either<L, R> as Iterator>::Item) -> Acc,
[src]Folds every element into an accumulator by applying an operation, returning the final result. Read more
pub fn count(self) -> usize
[src]
pub fn count(self) -> usize
[src]Consumes the iterator, counting the number of iterations and returning it. Read more
pub fn last(self) -> Option<<Either<L, R> as Iterator>::Item>
[src]
pub fn last(self) -> Option<<Either<L, R> as Iterator>::Item>
[src]Consumes the iterator, returning the last element. Read more
pub fn nth(&mut self, n: usize) -> Option<<Either<L, R> as Iterator>::Item>
[src]
pub fn nth(&mut self, n: usize) -> Option<<Either<L, R> as Iterator>::Item>
[src]Returns the n
th element of the iterator. Read more
pub fn collect<B>(self) -> B where
B: FromIterator<<Either<L, R> as Iterator>::Item>,
[src]
pub fn collect<B>(self) -> B where
B: FromIterator<<Either<L, R> as Iterator>::Item>,
[src]Transforms an iterator into a collection. Read more
pub fn all<F>(&mut self, f: F) -> bool where
F: FnMut(<Either<L, R> as Iterator>::Item) -> bool,
[src]
pub fn all<F>(&mut self, f: F) -> bool where
F: FnMut(<Either<L, R> as Iterator>::Item) -> bool,
[src]Tests if every element of the iterator matches a predicate. Read more
fn advance_by(&mut self, n: usize) -> Result<(), usize>
[src]
fn advance_by(&mut self, n: usize) -> Result<(), usize>
[src]🔬 This is a nightly-only experimental API. (iter_advance_by
)
recently added
Advances the iterator by n
elements. Read more
fn step_by(self, step: usize) -> StepBy<Self>
1.28.0[src]
fn step_by(self, step: usize) -> StepBy<Self>
1.28.0[src]Creates an iterator starting at the same point, but stepping by the given amount at each iteration. Read more
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator<Item = Self::Item>,
1.0.0[src]
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator<Item = Self::Item>,
1.0.0[src]Takes two iterators and creates a new iterator over both in sequence. Read more
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator,
1.0.0[src]
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator,
1.0.0[src]‘Zips up’ two iterators into a single iterator of pairs. Read more
fn intersperse(self, separator: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]
fn intersperse(self, separator: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]🔬 This is a nightly-only experimental API. (iter_intersperse
)
recently added
Creates a new iterator which places a copy of separator
between adjacent
items of the original iterator. Read more
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G> where
G: FnMut() -> Self::Item,
[src]
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G> where
G: FnMut() -> Self::Item,
[src]🔬 This is a nightly-only experimental API. (iter_intersperse
)
recently added
Creates a new iterator which places an item generated by separator
between adjacent items of the original iterator. Read more
fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B,
1.0.0[src]
fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B,
1.0.0[src]Takes a closure and creates an iterator which calls that closure on each element. Read more
fn for_each<F>(self, f: F) where
F: FnMut(Self::Item),
1.21.0[src]
fn for_each<F>(self, f: F) where
F: FnMut(Self::Item),
1.21.0[src]Calls a closure on each element of an iterator. Read more
fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]Creates an iterator which uses a closure to determine if an element should be yielded. Read more
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>,
1.0.0[src]
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>,
1.0.0[src]Creates an iterator that both filters and maps. Read more
fn enumerate(self) -> Enumerate<Self>
1.0.0[src]
fn enumerate(self) -> Enumerate<Self>
1.0.0[src]Creates an iterator which gives the current iteration count as well as the next value. Read more
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]Creates an iterator that yields elements based on a predicate. Read more
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> where
P: FnMut(Self::Item) -> Option<B>,
[src]
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> where
P: FnMut(Self::Item) -> Option<B>,
[src]🔬 This is a nightly-only experimental API. (iter_map_while
)
recently added
Creates an iterator that both yields elements based on a predicate and maps. Read more
fn skip(self, n: usize) -> Skip<Self>
1.0.0[src]
fn skip(self, n: usize) -> Skip<Self>
1.0.0[src]Creates an iterator that skips the first n
elements. Read more
fn take(self, n: usize) -> Take<Self>
1.0.0[src]
fn take(self, n: usize) -> Take<Self>
1.0.0[src]Creates an iterator that yields the first n
elements, or fewer
if the underlying iterator ends sooner. Read more
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
F: FnMut(&mut St, Self::Item) -> Option<B>,
1.0.0[src]
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
F: FnMut(&mut St, Self::Item) -> Option<B>,
1.0.0[src]fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: IntoIterator,
1.0.0[src]
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: IntoIterator,
1.0.0[src]Creates an iterator that works like map, but flattens nested structure. Read more
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoIterator,
1.29.0[src]
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoIterator,
1.29.0[src]Creates an iterator that flattens nested structure. Read more
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
1.0.0[src]
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
1.0.0[src]Does something with each element of an iterator, passing the value on. Read more
fn partition<B, F>(self, f: F) -> (B, B) where
F: FnMut(&Self::Item) -> bool,
B: Default + Extend<Self::Item>,
1.0.0[src]
fn partition<B, F>(self, f: F) -> (B, B) where
F: FnMut(&Self::Item) -> bool,
B: Default + Extend<Self::Item>,
1.0.0[src]Consumes an iterator, creating two collections from it. Read more
fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
Self: DoubleEndedIterator<Item = &'a mut T>,
P: FnMut(&T) -> bool,
T: 'a,
[src]
fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
Self: DoubleEndedIterator<Item = &'a mut T>,
P: FnMut(&T) -> bool,
T: 'a,
[src]🔬 This is a nightly-only experimental API. (iter_partition_in_place
)
new API
Reorders the elements of this iterator in-place according to the given predicate,
such that all those that return true
precede all those that return false
.
Returns the number of true
elements found. Read more
fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool,
[src]
fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool,
[src]🔬 This is a nightly-only experimental API. (iter_is_partitioned
)
new API
Checks if the elements of this iterator are partitioned according to the given predicate,
such that all those that return true
precede all those that return false
. Read more
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
1.27.0[src]
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
1.27.0[src]An iterator method that applies a function as long as it returns successfully, producing a single, final value. Read more
fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
1.27.0[src]
fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
1.27.0[src]An iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error. Read more
fn reduce<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
1.51.0[src]
fn reduce<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
1.51.0[src]Reduces the elements to a single one, by repeatedly applying a reducing operation. Read more
fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
1.0.0[src]
fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
1.0.0[src]Tests if any element of the iterator matches a predicate. Read more
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]Searches for an element of an iterator that satisfies a predicate. Read more
fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>,
1.30.0[src]
fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>,
1.30.0[src]Applies function to the elements of iterator and returns the first non-none result. Read more
fn try_find<F, R>(
&mut self,
f: F
) -> Result<Option<Self::Item>, <R as Try>::Error> where
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool>,
[src]
fn try_find<F, R>(
&mut self,
f: F
) -> Result<Option<Self::Item>, <R as Try>::Error> where
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool>,
[src]🔬 This is a nightly-only experimental API. (try_find
)
new API
Applies function to the elements of iterator and returns the first true result or the first error. Read more
fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
1.0.0[src]
fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
1.0.0[src]Searches for an element in an iterator, returning its index. Read more
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
Self: ExactSizeIterator + DoubleEndedIterator,
P: FnMut(Self::Item) -> bool,
1.0.0[src]
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
Self: ExactSizeIterator + DoubleEndedIterator,
P: FnMut(Self::Item) -> bool,
1.0.0[src]Searches for an element in an iterator from the right, returning its index. Read more
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]Returns the maximum element of an iterator. Read more
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]Returns the minimum element of an iterator. Read more
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
F: FnMut(&Self::Item) -> B,
B: Ord,
1.6.0[src]
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
F: FnMut(&Self::Item) -> B,
B: Ord,
1.6.0[src]Returns the element that gives the maximum value from the specified function. Read more
fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]Returns the element that gives the maximum value with respect to the specified comparison function. Read more
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
F: FnMut(&Self::Item) -> B,
B: Ord,
1.6.0[src]
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
F: FnMut(&Self::Item) -> B,
B: Ord,
1.6.0[src]Returns the element that gives the minimum value from the specified function. Read more
fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]Returns the element that gives the minimum value with respect to the specified comparison function. Read more
fn rev(self) -> Rev<Self> where
Self: DoubleEndedIterator,
1.0.0[src]
fn rev(self) -> Rev<Self> where
Self: DoubleEndedIterator,
1.0.0[src]Reverses an iterator’s direction. Read more
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
Self: Iterator<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
1.0.0[src]
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
Self: Iterator<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
1.0.0[src]Converts an iterator of pairs into a pair of containers. Read more
fn copied<'a, T>(self) -> Copied<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
1.36.0[src]
fn copied<'a, T>(self) -> Copied<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
1.36.0[src]Creates an iterator which copies all of its elements. Read more
fn cloned<'a, T>(self) -> Cloned<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
1.0.0[src]
fn cloned<'a, T>(self) -> Cloned<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
1.0.0[src]fn sum<S>(self) -> S where
S: Sum<Self::Item>,
1.11.0[src]
fn sum<S>(self) -> S where
S: Sum<Self::Item>,
1.11.0[src]Sums the elements of an iterator. Read more
fn product<P>(self) -> P where
P: Product<Self::Item>,
1.11.0[src]
fn product<P>(self) -> P where
P: Product<Self::Item>,
1.11.0[src]Iterates over the entire iterator, multiplying all the elements Read more
fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
1.5.0[src]
fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
1.5.0[src]Lexicographically compares the elements of this Iterator
with those
of another. Read more
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator,
[src]
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator,
[src]iter_order_by
)Lexicographically compares the elements of this Iterator
with those
of another with respect to the specified comparison function. Read more
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]Lexicographically compares the elements of this Iterator
with those
of another. Read more
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator,
[src]
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator,
[src]iter_order_by
)Lexicographically compares the elements of this Iterator
with those
of another with respect to the specified comparison function. Read more
fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]fn eq_by<I, F>(self, other: I, eq: F) -> bool where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator,
[src]
fn eq_by<I, F>(self, other: I, eq: F) -> bool where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator,
[src]iter_order_by
)fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]Determines if the elements of this Iterator
are lexicographically
less than those of another. Read more
fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]Determines if the elements of this Iterator
are lexicographically
less or equal to those of another. Read more
fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]Determines if the elements of this Iterator
are lexicographically
greater than those of another. Read more
fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]Determines if the elements of this Iterator
are lexicographically
greater than or equal to those of another. Read more
fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>,
[src]
fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>,
[src]🔬 This is a nightly-only experimental API. (is_sorted
)
new API
Checks if the elements of this iterator are sorted. Read more
fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
[src]
fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
[src]🔬 This is a nightly-only experimental API. (is_sorted
)
new API
Checks if the elements of this iterator are sorted using the given comparator function. Read more
fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
[src]
fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
[src]🔬 This is a nightly-only experimental API. (is_sorted
)
new API
Checks if the elements of this iterator are sorted using the given key extraction function. Read more
impl<L, R> Ord for Either<L, R> where
R: Ord,
L: Ord,
[src]
impl<L, R> Ord for Either<L, R> where
R: Ord,
L: Ord,
[src]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>,
[src]
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>,
[src]fn par_extend<I>(&mut self, pi: I) where
I: IntoParallelIterator<Item = Either<L, R>>,
[src]
fn par_extend<I>(&mut self, pi: I) where
I: IntoParallelIterator<Item = Either<L, R>>,
[src]Extends an instance of the collection with the elements drawn
from the parallel iterator par_iter
. Read more
impl<L, R, T> ParallelExtend<T> for Either<L, R> where
L: ParallelExtend<T>,
R: ParallelExtend<T>,
T: Send,
[src]
impl<L, R, T> ParallelExtend<T> for Either<L, R> where
L: ParallelExtend<T>,
R: ParallelExtend<T>,
T: Send,
[src]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>,
[src]
fn par_extend<I>(&mut self, par_iter: I) where
I: IntoParallelIterator<Item = T>,
[src]Extends an instance of the collection with the elements drawn
from the parallel iterator par_iter
. Read more
impl<L, R> ParallelIterator for Either<L, R> where
L: ParallelIterator,
R: ParallelIterator<Item = L::Item>,
[src]
impl<L, R> ParallelIterator for Either<L, R> where
L: ParallelIterator,
R: ParallelIterator<Item = L::Item>,
[src]Either<L, R>
is a parallel iterator if both L
and R
are parallel iterators.
fn drive_unindexed<C>(self, consumer: C) -> C::Result where
C: UnindexedConsumer<Self::Item>,
[src]
fn drive_unindexed<C>(self, consumer: C) -> C::Result where
C: UnindexedConsumer<Self::Item>,
[src]Internal method used to define the behavior of this parallel iterator. You should not need to call this directly. Read more
fn opt_len(&self) -> Option<usize>
[src]
fn opt_len(&self) -> Option<usize>
[src]Internal method used to define the behavior of this parallel iterator. You should not need to call this directly. Read more
fn for_each<OP>(self, op: OP) where
OP: Fn(Self::Item) + Sync + Send,
[src]
fn for_each<OP>(self, op: OP) where
OP: Fn(Self::Item) + Sync + Send,
[src]Executes OP
on each item produced by the iterator, in parallel. Read more
fn for_each_with<OP, T>(self, init: T, op: OP) where
OP: Fn(&mut T, Self::Item) + Sync + Send,
T: Send + Clone,
[src]
fn for_each_with<OP, T>(self, init: T, op: OP) where
OP: Fn(&mut T, Self::Item) + Sync + Send,
T: Send + Clone,
[src]Executes OP
on the given init
value with each item produced by
the iterator, in parallel. Read more
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,
[src]
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,
[src]Executes OP
on a value returned by init
with each item produced by
the iterator, in parallel. Read more
fn try_for_each<OP, R>(self, op: OP) -> R where
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
[src]
fn try_for_each<OP, R>(self, op: OP) -> R where
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
[src]Executes a fallible OP
on each item produced by the iterator, in parallel. Read more
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Try<Ok = ()> + Send,
[src]
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Try<Ok = ()> + Send,
[src]Executes a fallible OP
on the given init
value with each item
produced by the iterator, in parallel. Read more
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Try<Ok = ()> + Send,
[src]
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Try<Ok = ()> + Send,
[src]Executes a fallible OP
on a value returned by init
with each item
produced by the iterator, in parallel. Read more
fn map<F, R>(self, map_op: F) -> Map<Self, F> where
F: Fn(Self::Item) -> R + Sync + Send,
R: Send,
[src]
fn map<F, R>(self, map_op: F) -> Map<Self, F> where
F: Fn(Self::Item) -> R + Sync + Send,
R: Send,
[src]Applies map_op
to each item of this iterator, producing a new
iterator with the results. Read more
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,
[src]
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,
[src]Applies map_op
to the given init
value with each item of this
iterator, producing a new iterator with the results. Read more
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,
[src]
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,
[src]Applies map_op
to a value returned by init
with each item of this
iterator, producing a new iterator with the results. Read more
fn cloned<'a, T>(self) -> Cloned<Self> where
T: 'a + Clone + Send,
Self: ParallelIterator<Item = &'a T>,
[src]
fn cloned<'a, T>(self) -> Cloned<Self> where
T: 'a + Clone + Send,
Self: ParallelIterator<Item = &'a T>,
[src]fn copied<'a, T>(self) -> Copied<Self> where
T: 'a + Copy + Send,
Self: ParallelIterator<Item = &'a T>,
[src]
fn copied<'a, T>(self) -> Copied<Self> where
T: 'a + Copy + Send,
Self: ParallelIterator<Item = &'a T>,
[src]fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
OP: Fn(&Self::Item) + Sync + Send,
[src]
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
OP: Fn(&Self::Item) + Sync + Send,
[src]Applies 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 more
fn update<F>(self, update_op: F) -> Update<Self, F> where
F: Fn(&mut Self::Item) + Sync + Send,
[src]
fn update<F>(self, update_op: F) -> Update<Self, F> where
F: Fn(&mut Self::Item) + Sync + Send,
[src]Mutates each item of this iterator before yielding it. Read more
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]Applies filter_op
to each item of this iterator, producing a new
iterator with only the items that gave true
results. Read more
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]Applies filter_op
to each item of this iterator to get an Option
,
producing a new iterator with only the items from Some
results. Read more
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
[src]
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
[src]Applies 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 more
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,
[src]
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,
[src]Applies 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 more
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoParallelIterator,
[src]
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoParallelIterator,
[src]An adaptor that flattens parallel-iterable Item
s into one large iterator. Read more
fn flatten_iter(self) -> FlattenIter<Self> where
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
[src]
fn flatten_iter(self) -> FlattenIter<Self> where
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
[src]An adaptor that flattens serial-iterable Item
s into one large iterator. Read more
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
ID: Fn() -> Self::Item + Sync + Send,
[src]
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
ID: Fn() -> Self::Item + Sync + Send,
[src]Reduces the items in the iterator into one item using 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 more
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
[src]
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
[src]Reduces the items in the iterator into one item using op
.
If the iterator is empty, None
is returned; otherwise,
Some
is returned. Read more
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
OP: Fn(T, T) -> Self::Item + Sync + Send,
ID: Fn() -> T + Sync + Send,
Self::Item: Try<Ok = T>,
[src]
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
OP: Fn(T, T) -> Self::Item + Sync + Send,
ID: Fn() -> T + Sync + Send,
Self::Item: Try<Ok = T>,
[src]fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
OP: Fn(T, T) -> Self::Item + Sync + Send,
Self::Item: Try<Ok = T>,
[src]
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
OP: Fn(T, T) -> Self::Item + Sync + Send,
Self::Item: Try<Ok = T>,
[src]Reduces the items in the iterator into one item using a fallible op
. Read more
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,
[src]
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,
[src]Parallel fold is similar to sequential fold except that the
sequence of items may be subdivided before it is
folded. Consider a list of numbers like 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 more
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,
[src]
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,
[src]Applies fold_op
to the given init
value with each item of this
iterator, finally producing the value for further use. Read more
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<Ok = T> + Send,
[src]
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<Ok = T> + Send,
[src]Performs a fallible parallel fold. Read more
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<Ok = T> + Send,
T: Clone + Send,
[src]
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<Ok = T> + Send,
T: Clone + Send,
[src]Performs a fallible parallel fold with a cloneable init
value. Read more
fn sum<S>(self) -> S where
S: Send + Sum<Self::Item> + Sum<S>,
[src]
fn sum<S>(self) -> S where
S: Send + Sum<Self::Item> + Sum<S>,
[src]Sums up the items in the iterator. Read more
fn product<P>(self) -> P where
P: Send + Product<Self::Item> + Product<P>,
[src]
fn product<P>(self) -> P where
P: Send + Product<Self::Item> + Product<P>,
[src]Multiplies all the items in the iterator. Read more
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]Computes the minimum of all the items in the iterator. If the
iterator is empty, None
is returned; otherwise, Some(min)
is returned. Read more
fn min_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
fn min_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]Computes the minimum of all the items in the iterator with respect to
the given comparison function. If the iterator is empty, None
is
returned; otherwise, Some(min)
is returned. Read more
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]Computes the item that yields the minimum value for the given
function. If the iterator is empty, None
is returned;
otherwise, Some(item)
is returned. Read more
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]Computes the maximum of all the items in the iterator. If the
iterator is empty, None
is returned; otherwise, Some(max)
is returned. Read more
fn max_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
fn max_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]Computes the maximum of all the items in the iterator with respect to
the given comparison function. If the iterator is empty, None
is
returned; otherwise, Some(min)
is returned. Read more
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]Computes the item that yields the maximum value for the given
function. If the iterator is empty, None
is returned;
otherwise, Some(item)
is returned. Read more
fn chain<C>(self, chain: C) -> Chain<Self, C::Iter> where
C: IntoParallelIterator<Item = Self::Item>,
[src]
fn chain<C>(self, chain: C) -> Chain<Self, C::Iter> where
C: IntoParallelIterator<Item = Self::Item>,
[src]Takes two iterators and creates a new iterator over both. Read more
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]Searches for some item in the parallel iterator that
matches the given predicate and returns it. This operation
is similar to 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 more
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]Searches for the sequentially first item in the parallel iterator that matches the given predicate and returns it. Read more
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]Searches for the sequentially last item in the parallel iterator that matches the given predicate and returns it. Read more
fn find_map_any<P, R>(self, predicate: P) -> Option<R> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]
fn find_map_any<P, R>(self, predicate: P) -> Option<R> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]Applies the given predicate to the items in the parallel iterator and returns any non-None result of the map operation. Read more
fn find_map_first<P, R>(self, predicate: P) -> Option<R> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]
fn find_map_first<P, R>(self, predicate: P) -> Option<R> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]Applies the given predicate to the items in the parallel iterator and returns the sequentially first non-None result of the map operation. Read more
fn find_map_last<P, R>(self, predicate: P) -> Option<R> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]
fn find_map_last<P, R>(self, predicate: P) -> Option<R> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]Applies the given predicate to the items in the parallel iterator and returns the sequentially last non-None result of the map operation. Read more
fn any<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
fn any<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]Searches for some item in the parallel iterator that matches the given predicate, and if so returns true. Once a match is found, we’ll attempt to stop process the rest of the items. Proving that there’s no match, returning false, does require visiting every item. Read more
fn all<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
fn all<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]Tests that every item in the parallel iterator matches the given predicate, and if so returns true. If a counter-example is found, we’ll attempt to stop processing more items, then return false. Read more
fn while_some<T>(self) -> WhileSome<Self> where
Self: ParallelIterator<Item = Option<T>>,
T: Send,
[src]
fn while_some<T>(self) -> WhileSome<Self> where
Self: ParallelIterator<Item = Option<T>>,
T: Send,
[src]Creates an iterator over the Some
items of this iterator, halting
as soon as any None
is found. Read more
fn panic_fuse(self) -> PanicFuse<Self>
[src]
fn panic_fuse(self) -> PanicFuse<Self>
[src]Wraps an iterator with a fuse in case of panics, to halt all threads as soon as possible. Read more
fn collect<C>(self) -> C where
C: FromParallelIterator<Self::Item>,
[src]
fn collect<C>(self) -> C where
C: FromParallelIterator<Self::Item>,
[src]Creates a fresh collection containing all the elements produced by this parallel iterator. Read more
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,
[src]
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,
[src]Unzips the items of a parallel iterator into a pair of arbitrary
ParallelExtend
containers. Read more
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,
[src]
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,
[src]Partitions the items of a parallel iterator into a pair of arbitrary
ParallelExtend
containers. Items for which the predicate
returns
true go into the first container, and the rest go into the second. Read more
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,
[src]
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,
[src]Partitions and maps the items of a parallel iterator into a pair of
arbitrary ParallelExtend
containers. Either::Left
items go into
the first container, and Either::Right
items go into the second. Read more
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]Intersperses clones of an element between items of this iterator. Read more
impl<L, R> PartialOrd<Either<L, R>> for Either<L, R> where
R: PartialOrd<R>,
L: PartialOrd<L>,
[src]
impl<L, R> PartialOrd<Either<L, R>> for Either<L, R> where
R: PartialOrd<R>,
L: PartialOrd<L>,
[src]pub fn partial_cmp(&self, other: &Either<L, R>) -> Option<Ordering>
[src]
pub fn partial_cmp(&self, other: &Either<L, R>) -> Option<Ordering>
[src]This method returns an ordering between self
and other
values if one exists. Read more
#[must_use]fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]fn lt(&self, other: &Rhs) -> bool
1.0.0[src]This method tests less than (for self
and other
) and is used by the <
operator. Read more
#[must_use]fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]fn le(&self, other: &Rhs) -> bool
1.0.0[src]This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
impl<L, R> Copy for Either<L, R> where
R: Copy,
L: Copy,
[src]
R: Copy,
L: Copy,
impl<L, R> Eq for Either<L, R> where
R: Eq,
L: Eq,
[src]
R: Eq,
L: Eq,
impl<L, R> StructuralEq for Either<L, R>
[src]
impl<L, R> StructuralPartialEq for Either<L, R>
[src]
Auto Trait Implementations
impl<L, R> RefUnwindSafe for Either<L, R> where
L: RefUnwindSafe,
R: RefUnwindSafe,
L: RefUnwindSafe,
R: RefUnwindSafe,
impl<L, R> Send for Either<L, R> where
L: Send,
R: Send,
L: Send,
R: Send,
impl<L, R> Sync for Either<L, R> where
L: Sync,
R: Sync,
L: Sync,
R: Sync,
impl<L, R> Unpin for Either<L, R> where
L: Unpin,
R: Unpin,
L: Unpin,
R: Unpin,
impl<L, R> UnwindSafe for Either<L, R> where
L: UnwindSafe,
R: UnwindSafe,
L: UnwindSafe,
R: UnwindSafe,
Blanket Implementations
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]pub fn borrow_mut(&mut self) -> &mut T
[src]
pub fn borrow_mut(&mut self) -> &mut T
[src]Mutably borrows from an owned value. Read more
impl<I> IntoIterator for I where
I: Iterator,
[src]
impl<I> IntoIterator for I where
I: Iterator,
[src]impl<T> IntoParallelIterator for T where
T: ParallelIterator,
[src]
impl<T> IntoParallelIterator for T where
T: ParallelIterator,
[src]type Iter = T
type Iter = T
The parallel iterator type that will be created.
type Item = <T as ParallelIterator>::Item
type Item = <T as ParallelIterator>::Item
The type of item that the parallel iterator will produce.
pub fn into_par_iter(Self) -> T
[src]
pub fn into_par_iter(Self) -> T
[src]Converts self
into a parallel iterator. Read more
impl<T> Pointable for T
impl<T> Pointable for T
impl<T> ToOwned for T where
T: Clone,
[src]
impl<T> ToOwned for T where
T: Clone,
[src]type Owned = T
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn to_owned(&self) -> T
[src]Creates owned data from borrowed data, usually by cloning. Read more
pub fn clone_into(&self, target: &mut T)
[src]
pub fn clone_into(&self, target: &mut T)
[src]🔬 This is a nightly-only experimental API. (toowned_clone_into
)
recently added
Uses borrowed data to replace owned data, usually by cloning. Read more