Struct rayon::iter::MultiZip [−][src]
MultiZip
is an iterator that zips up a tuple of parallel iterators to
produce tuples of their items.
It is created by calling into_par_iter()
on a tuple of types that
implement IntoParallelIterator
, or par_iter()
/par_iter_mut()
with
types that are iterable by reference.
The implementation currently support tuples up to length 12.
Examples
use rayon::prelude::*; // This will iterate `r` by mutable reference, like `par_iter_mut()`, while // ranges are all iterated by value like `into_par_iter()`. // Note that the zipped iterator is only as long as the shortest input. let mut r = vec![0; 3]; (&mut r, 1..10, 10..100, 100..1000).into_par_iter() .for_each(|(r, x, y, z)| *r = x * y + z); assert_eq!(&r, &[1 * 10 + 100, 2 * 11 + 101, 3 * 12 + 102]);
For a group that should all be iterated by reference, you can use a tuple reference.
use rayon::prelude::*; let xs: Vec<_> = (1..10).collect(); let ys: Vec<_> = (10..100).collect(); let zs: Vec<_> = (100..1000).collect(); // Reference each input separately with `IntoParallelIterator`: let r1: Vec<_> = (&xs, &ys, &zs).into_par_iter() .map(|(x, y, z)| x * y + z) .collect(); // Reference them all together with `IntoParallelRefIterator`: let r2: Vec<_> = (xs, ys, zs).par_iter() .map(|(x, y, z)| x * y + z) .collect(); assert_eq!(r1, r2);
Mutable references to a tuple will work similarly.
use rayon::prelude::*; let mut xs: Vec<_> = (1..4).collect(); let mut ys: Vec<_> = (-4..-1).collect(); let mut zs = vec![0; 3]; // Mutably reference each input separately with `IntoParallelIterator`: (&mut xs, &mut ys, &mut zs).into_par_iter().for_each(|(x, y, z)| { *z += *x + *y; std::mem::swap(x, y); }); assert_eq!(xs, (vec![-4, -3, -2])); assert_eq!(ys, (vec![1, 2, 3])); assert_eq!(zs, (vec![-3, -1, 1])); // Mutably reference them all together with `IntoParallelRefMutIterator`: let mut tuple = (xs, ys, zs); tuple.par_iter_mut().for_each(|(x, y, z)| { *z += *x + *y; std::mem::swap(x, y); }); assert_eq!(tuple, (vec![1, 2, 3], vec![-4, -3, -2], vec![-6, -2, 2]));
Trait Implementations
impl<T: Clone> Clone for MultiZip<T>
[src]
impl<T: Debug> Debug for MultiZip<T>
[src]
impl<A> IndexedParallelIterator for MultiZip<(A,)> where
A: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
fn drive<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result where
CONSUMER: Consumer<Self::Item>,
[src]
CONSUMER: Consumer<Self::Item>,
fn len(&self) -> usize
[src]
fn with_producer<CB>(self, callback: CB) -> CB::Output where
CB: ProducerCallback<Self::Item>,
[src]
CB: ProducerCallback<Self::Item>,
fn collect_into_vec(self, target: &mut Vec<Self::Item>)
[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]
Self: IndexedParallelIterator<Item = (A, B)>,
A: Send,
B: Send,
fn zip<Z>(self, zip_op: Z) -> Zip<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn interleave<I>(self, other: I) -> Interleave<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn interleave_shortest<I>(self, other: I) -> InterleaveShortest<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn chunks(self, chunk_size: usize) -> Chunks<Self>
[src]
fn cmp<I>(self, other: I) -> Ordering where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn eq<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn ne<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn lt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn le<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn gt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn ge<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn enumerate(self) -> Enumerate<Self>
[src]
fn step_by(self, step: usize) -> StepBy<Self>
[src]
fn skip(self, n: usize) -> Skip<Self>
[src]
fn take(self, n: usize) -> Take<Self>
[src]
fn position_any<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_first<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_last<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn positions<P>(self, predicate: P) -> Positions<Self, P> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn rev(self) -> Rev<Self>
[src]
fn with_min_len(self, min: usize) -> MinLen<Self>
[src]
fn with_max_len(self, max: usize) -> MaxLen<Self>
[src]
impl<A, B> IndexedParallelIterator for MultiZip<(A, B)> where
A: IndexedParallelIterator,
B: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator,
fn drive<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result where
CONSUMER: Consumer<Self::Item>,
[src]
CONSUMER: Consumer<Self::Item>,
fn len(&self) -> usize
[src]
fn with_producer<CB>(self, callback: CB) -> CB::Output where
CB: ProducerCallback<Self::Item>,
[src]
CB: ProducerCallback<Self::Item>,
fn collect_into_vec(self, target: &mut Vec<Self::Item>)
[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]
Self: IndexedParallelIterator<Item = (A, B)>,
A: Send,
B: Send,
fn zip<Z>(self, zip_op: Z) -> Zip<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn interleave<I>(self, other: I) -> Interleave<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn interleave_shortest<I>(self, other: I) -> InterleaveShortest<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn chunks(self, chunk_size: usize) -> Chunks<Self>
[src]
fn cmp<I>(self, other: I) -> Ordering where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn eq<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn ne<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn lt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn le<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn gt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn ge<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn enumerate(self) -> Enumerate<Self>
[src]
fn step_by(self, step: usize) -> StepBy<Self>
[src]
fn skip(self, n: usize) -> Skip<Self>
[src]
fn take(self, n: usize) -> Take<Self>
[src]
fn position_any<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_first<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_last<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn positions<P>(self, predicate: P) -> Positions<Self, P> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn rev(self) -> Rev<Self>
[src]
fn with_min_len(self, min: usize) -> MinLen<Self>
[src]
fn with_max_len(self, max: usize) -> MaxLen<Self>
[src]
impl<A, B, C, D, E, F, G, H, I, J, K> IndexedParallelIterator for MultiZip<(A, B, C, D, E, F, G, H, I, J, K)> where
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
G: IndexedParallelIterator,
H: IndexedParallelIterator,
I: IndexedParallelIterator,
J: IndexedParallelIterator,
K: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
G: IndexedParallelIterator,
H: IndexedParallelIterator,
I: IndexedParallelIterator,
J: IndexedParallelIterator,
K: IndexedParallelIterator,
fn drive<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result where
CONSUMER: Consumer<Self::Item>,
[src]
CONSUMER: Consumer<Self::Item>,
fn len(&self) -> usize
[src]
fn with_producer<CB>(self, callback: CB) -> CB::Output where
CB: ProducerCallback<Self::Item>,
[src]
CB: ProducerCallback<Self::Item>,
fn collect_into_vec(self, target: &mut Vec<Self::Item>)
[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]
Self: IndexedParallelIterator<Item = (A, B)>,
A: Send,
B: Send,
fn zip<Z>(self, zip_op: Z) -> Zip<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn interleave<I>(self, other: I) -> Interleave<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn interleave_shortest<I>(self, other: I) -> InterleaveShortest<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn chunks(self, chunk_size: usize) -> Chunks<Self>
[src]
fn cmp<I>(self, other: I) -> Ordering where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn eq<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn ne<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn lt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn le<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn gt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn ge<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn enumerate(self) -> Enumerate<Self>
[src]
fn step_by(self, step: usize) -> StepBy<Self>
[src]
fn skip(self, n: usize) -> Skip<Self>
[src]
fn take(self, n: usize) -> Take<Self>
[src]
fn position_any<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_first<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_last<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn positions<P>(self, predicate: P) -> Positions<Self, P> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn rev(self) -> Rev<Self>
[src]
fn with_min_len(self, min: usize) -> MinLen<Self>
[src]
fn with_max_len(self, max: usize) -> MaxLen<Self>
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L> IndexedParallelIterator for MultiZip<(A, B, C, D, E, F, G, H, I, J, K, L)> where
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
G: IndexedParallelIterator,
H: IndexedParallelIterator,
I: IndexedParallelIterator,
J: IndexedParallelIterator,
K: IndexedParallelIterator,
L: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
G: IndexedParallelIterator,
H: IndexedParallelIterator,
I: IndexedParallelIterator,
J: IndexedParallelIterator,
K: IndexedParallelIterator,
L: IndexedParallelIterator,
fn drive<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result where
CONSUMER: Consumer<Self::Item>,
[src]
CONSUMER: Consumer<Self::Item>,
fn len(&self) -> usize
[src]
fn with_producer<CB>(self, callback: CB) -> CB::Output where
CB: ProducerCallback<Self::Item>,
[src]
CB: ProducerCallback<Self::Item>,
fn collect_into_vec(self, target: &mut Vec<Self::Item>)
[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]
Self: IndexedParallelIterator<Item = (A, B)>,
A: Send,
B: Send,
fn zip<Z>(self, zip_op: Z) -> Zip<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn interleave<I>(self, other: I) -> Interleave<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn interleave_shortest<I>(self, other: I) -> InterleaveShortest<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn chunks(self, chunk_size: usize) -> Chunks<Self>
[src]
fn cmp<I>(self, other: I) -> Ordering where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn eq<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn ne<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn lt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn le<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn gt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn ge<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn enumerate(self) -> Enumerate<Self>
[src]
fn step_by(self, step: usize) -> StepBy<Self>
[src]
fn skip(self, n: usize) -> Skip<Self>
[src]
fn take(self, n: usize) -> Take<Self>
[src]
fn position_any<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_first<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_last<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn positions<P>(self, predicate: P) -> Positions<Self, P> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn rev(self) -> Rev<Self>
[src]
fn with_min_len(self, min: usize) -> MinLen<Self>
[src]
fn with_max_len(self, max: usize) -> MaxLen<Self>
[src]
impl<A, B, C> IndexedParallelIterator for MultiZip<(A, B, C)> where
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
fn drive<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result where
CONSUMER: Consumer<Self::Item>,
[src]
CONSUMER: Consumer<Self::Item>,
fn len(&self) -> usize
[src]
fn with_producer<CB>(self, callback: CB) -> CB::Output where
CB: ProducerCallback<Self::Item>,
[src]
CB: ProducerCallback<Self::Item>,
fn collect_into_vec(self, target: &mut Vec<Self::Item>)
[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]
Self: IndexedParallelIterator<Item = (A, B)>,
A: Send,
B: Send,
fn zip<Z>(self, zip_op: Z) -> Zip<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn interleave<I>(self, other: I) -> Interleave<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn interleave_shortest<I>(self, other: I) -> InterleaveShortest<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn chunks(self, chunk_size: usize) -> Chunks<Self>
[src]
fn cmp<I>(self, other: I) -> Ordering where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn eq<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn ne<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn lt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn le<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn gt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn ge<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn enumerate(self) -> Enumerate<Self>
[src]
fn step_by(self, step: usize) -> StepBy<Self>
[src]
fn skip(self, n: usize) -> Skip<Self>
[src]
fn take(self, n: usize) -> Take<Self>
[src]
fn position_any<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_first<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_last<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn positions<P>(self, predicate: P) -> Positions<Self, P> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn rev(self) -> Rev<Self>
[src]
fn with_min_len(self, min: usize) -> MinLen<Self>
[src]
fn with_max_len(self, max: usize) -> MaxLen<Self>
[src]
impl<A, B, C, D> IndexedParallelIterator for MultiZip<(A, B, C, D)> where
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
fn drive<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result where
CONSUMER: Consumer<Self::Item>,
[src]
CONSUMER: Consumer<Self::Item>,
fn len(&self) -> usize
[src]
fn with_producer<CB>(self, callback: CB) -> CB::Output where
CB: ProducerCallback<Self::Item>,
[src]
CB: ProducerCallback<Self::Item>,
fn collect_into_vec(self, target: &mut Vec<Self::Item>)
[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]
Self: IndexedParallelIterator<Item = (A, B)>,
A: Send,
B: Send,
fn zip<Z>(self, zip_op: Z) -> Zip<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn interleave<I>(self, other: I) -> Interleave<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn interleave_shortest<I>(self, other: I) -> InterleaveShortest<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn chunks(self, chunk_size: usize) -> Chunks<Self>
[src]
fn cmp<I>(self, other: I) -> Ordering where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn eq<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn ne<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn lt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn le<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn gt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn ge<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn enumerate(self) -> Enumerate<Self>
[src]
fn step_by(self, step: usize) -> StepBy<Self>
[src]
fn skip(self, n: usize) -> Skip<Self>
[src]
fn take(self, n: usize) -> Take<Self>
[src]
fn position_any<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_first<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_last<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn positions<P>(self, predicate: P) -> Positions<Self, P> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn rev(self) -> Rev<Self>
[src]
fn with_min_len(self, min: usize) -> MinLen<Self>
[src]
fn with_max_len(self, max: usize) -> MaxLen<Self>
[src]
impl<A, B, C, D, E> IndexedParallelIterator for MultiZip<(A, B, C, D, E)> where
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
fn drive<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result where
CONSUMER: Consumer<Self::Item>,
[src]
CONSUMER: Consumer<Self::Item>,
fn len(&self) -> usize
[src]
fn with_producer<CB>(self, callback: CB) -> CB::Output where
CB: ProducerCallback<Self::Item>,
[src]
CB: ProducerCallback<Self::Item>,
fn collect_into_vec(self, target: &mut Vec<Self::Item>)
[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]
Self: IndexedParallelIterator<Item = (A, B)>,
A: Send,
B: Send,
fn zip<Z>(self, zip_op: Z) -> Zip<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn interleave<I>(self, other: I) -> Interleave<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn interleave_shortest<I>(self, other: I) -> InterleaveShortest<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn chunks(self, chunk_size: usize) -> Chunks<Self>
[src]
fn cmp<I>(self, other: I) -> Ordering where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn eq<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn ne<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn lt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn le<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn gt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn ge<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn enumerate(self) -> Enumerate<Self>
[src]
fn step_by(self, step: usize) -> StepBy<Self>
[src]
fn skip(self, n: usize) -> Skip<Self>
[src]
fn take(self, n: usize) -> Take<Self>
[src]
fn position_any<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_first<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_last<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn positions<P>(self, predicate: P) -> Positions<Self, P> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn rev(self) -> Rev<Self>
[src]
fn with_min_len(self, min: usize) -> MinLen<Self>
[src]
fn with_max_len(self, max: usize) -> MaxLen<Self>
[src]
impl<A, B, C, D, E, F> IndexedParallelIterator for MultiZip<(A, B, C, D, E, F)> where
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
fn drive<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result where
CONSUMER: Consumer<Self::Item>,
[src]
CONSUMER: Consumer<Self::Item>,
fn len(&self) -> usize
[src]
fn with_producer<CB>(self, callback: CB) -> CB::Output where
CB: ProducerCallback<Self::Item>,
[src]
CB: ProducerCallback<Self::Item>,
fn collect_into_vec(self, target: &mut Vec<Self::Item>)
[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]
Self: IndexedParallelIterator<Item = (A, B)>,
A: Send,
B: Send,
fn zip<Z>(self, zip_op: Z) -> Zip<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn interleave<I>(self, other: I) -> Interleave<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn interleave_shortest<I>(self, other: I) -> InterleaveShortest<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn chunks(self, chunk_size: usize) -> Chunks<Self>
[src]
fn cmp<I>(self, other: I) -> Ordering where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn eq<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn ne<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn lt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn le<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn gt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn ge<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn enumerate(self) -> Enumerate<Self>
[src]
fn step_by(self, step: usize) -> StepBy<Self>
[src]
fn skip(self, n: usize) -> Skip<Self>
[src]
fn take(self, n: usize) -> Take<Self>
[src]
fn position_any<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_first<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_last<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn positions<P>(self, predicate: P) -> Positions<Self, P> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn rev(self) -> Rev<Self>
[src]
fn with_min_len(self, min: usize) -> MinLen<Self>
[src]
fn with_max_len(self, max: usize) -> MaxLen<Self>
[src]
impl<A, B, C, D, E, F, G> IndexedParallelIterator for MultiZip<(A, B, C, D, E, F, G)> where
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
G: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
G: IndexedParallelIterator,
fn drive<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result where
CONSUMER: Consumer<Self::Item>,
[src]
CONSUMER: Consumer<Self::Item>,
fn len(&self) -> usize
[src]
fn with_producer<CB>(self, callback: CB) -> CB::Output where
CB: ProducerCallback<Self::Item>,
[src]
CB: ProducerCallback<Self::Item>,
fn collect_into_vec(self, target: &mut Vec<Self::Item>)
[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]
Self: IndexedParallelIterator<Item = (A, B)>,
A: Send,
B: Send,
fn zip<Z>(self, zip_op: Z) -> Zip<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn interleave<I>(self, other: I) -> Interleave<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn interleave_shortest<I>(self, other: I) -> InterleaveShortest<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn chunks(self, chunk_size: usize) -> Chunks<Self>
[src]
fn cmp<I>(self, other: I) -> Ordering where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn eq<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn ne<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn lt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn le<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn gt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn ge<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn enumerate(self) -> Enumerate<Self>
[src]
fn step_by(self, step: usize) -> StepBy<Self>
[src]
fn skip(self, n: usize) -> Skip<Self>
[src]
fn take(self, n: usize) -> Take<Self>
[src]
fn position_any<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_first<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_last<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn positions<P>(self, predicate: P) -> Positions<Self, P> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn rev(self) -> Rev<Self>
[src]
fn with_min_len(self, min: usize) -> MinLen<Self>
[src]
fn with_max_len(self, max: usize) -> MaxLen<Self>
[src]
impl<A, B, C, D, E, F, G, H> IndexedParallelIterator for MultiZip<(A, B, C, D, E, F, G, H)> where
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
G: IndexedParallelIterator,
H: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
G: IndexedParallelIterator,
H: IndexedParallelIterator,
fn drive<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result where
CONSUMER: Consumer<Self::Item>,
[src]
CONSUMER: Consumer<Self::Item>,
fn len(&self) -> usize
[src]
fn with_producer<CB>(self, callback: CB) -> CB::Output where
CB: ProducerCallback<Self::Item>,
[src]
CB: ProducerCallback<Self::Item>,
fn collect_into_vec(self, target: &mut Vec<Self::Item>)
[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]
Self: IndexedParallelIterator<Item = (A, B)>,
A: Send,
B: Send,
fn zip<Z>(self, zip_op: Z) -> Zip<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn interleave<I>(self, other: I) -> Interleave<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn interleave_shortest<I>(self, other: I) -> InterleaveShortest<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn chunks(self, chunk_size: usize) -> Chunks<Self>
[src]
fn cmp<I>(self, other: I) -> Ordering where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn eq<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn ne<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn lt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn le<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn gt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn ge<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn enumerate(self) -> Enumerate<Self>
[src]
fn step_by(self, step: usize) -> StepBy<Self>
[src]
fn skip(self, n: usize) -> Skip<Self>
[src]
fn take(self, n: usize) -> Take<Self>
[src]
fn position_any<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_first<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_last<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn positions<P>(self, predicate: P) -> Positions<Self, P> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn rev(self) -> Rev<Self>
[src]
fn with_min_len(self, min: usize) -> MinLen<Self>
[src]
fn with_max_len(self, max: usize) -> MaxLen<Self>
[src]
impl<A, B, C, D, E, F, G, H, I> IndexedParallelIterator for MultiZip<(A, B, C, D, E, F, G, H, I)> where
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
G: IndexedParallelIterator,
H: IndexedParallelIterator,
I: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
G: IndexedParallelIterator,
H: IndexedParallelIterator,
I: IndexedParallelIterator,
fn drive<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result where
CONSUMER: Consumer<Self::Item>,
[src]
CONSUMER: Consumer<Self::Item>,
fn len(&self) -> usize
[src]
fn with_producer<CB>(self, callback: CB) -> CB::Output where
CB: ProducerCallback<Self::Item>,
[src]
CB: ProducerCallback<Self::Item>,
fn collect_into_vec(self, target: &mut Vec<Self::Item>)
[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]
Self: IndexedParallelIterator<Item = (A, B)>,
A: Send,
B: Send,
fn zip<Z>(self, zip_op: Z) -> Zip<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn interleave<I>(self, other: I) -> Interleave<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn interleave_shortest<I>(self, other: I) -> InterleaveShortest<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn chunks(self, chunk_size: usize) -> Chunks<Self>
[src]
fn cmp<I>(self, other: I) -> Ordering where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn eq<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn ne<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn lt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn le<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn gt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn ge<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn enumerate(self) -> Enumerate<Self>
[src]
fn step_by(self, step: usize) -> StepBy<Self>
[src]
fn skip(self, n: usize) -> Skip<Self>
[src]
fn take(self, n: usize) -> Take<Self>
[src]
fn position_any<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_first<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_last<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn positions<P>(self, predicate: P) -> Positions<Self, P> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn rev(self) -> Rev<Self>
[src]
fn with_min_len(self, min: usize) -> MinLen<Self>
[src]
fn with_max_len(self, max: usize) -> MaxLen<Self>
[src]
impl<A, B, C, D, E, F, G, H, I, J> IndexedParallelIterator for MultiZip<(A, B, C, D, E, F, G, H, I, J)> where
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
G: IndexedParallelIterator,
H: IndexedParallelIterator,
I: IndexedParallelIterator,
J: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
G: IndexedParallelIterator,
H: IndexedParallelIterator,
I: IndexedParallelIterator,
J: IndexedParallelIterator,
fn drive<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result where
CONSUMER: Consumer<Self::Item>,
[src]
CONSUMER: Consumer<Self::Item>,
fn len(&self) -> usize
[src]
fn with_producer<CB>(self, callback: CB) -> CB::Output where
CB: ProducerCallback<Self::Item>,
[src]
CB: ProducerCallback<Self::Item>,
fn collect_into_vec(self, target: &mut Vec<Self::Item>)
[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]
Self: IndexedParallelIterator<Item = (A, B)>,
A: Send,
B: Send,
fn zip<Z>(self, zip_op: Z) -> Zip<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
fn interleave<I>(self, other: I) -> Interleave<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn interleave_shortest<I>(self, other: I) -> InterleaveShortest<Self, I::Iter> where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn chunks(self, chunk_size: usize) -> Chunks<Self>
[src]
fn cmp<I>(self, other: I) -> Ordering where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
[src]
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator,
Self::Item: Ord,
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn eq<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn ne<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialEq<I::Item>,
fn lt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn le<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn gt<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn ge<I>(self, other: I) -> bool where
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
[src]
I: IntoParallelIterator,
I::Iter: IndexedParallelIterator,
Self::Item: PartialOrd<I::Item>,
fn enumerate(self) -> Enumerate<Self>
[src]
fn step_by(self, step: usize) -> StepBy<Self>
[src]
fn skip(self, n: usize) -> Skip<Self>
[src]
fn take(self, n: usize) -> Take<Self>
[src]
fn position_any<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_first<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn position_last<P>(self, predicate: P) -> Option<usize> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn positions<P>(self, predicate: P) -> Positions<Self, P> where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn rev(self) -> Rev<Self>
[src]
fn with_min_len(self, min: usize) -> MinLen<Self>
[src]
fn with_max_len(self, max: usize) -> MaxLen<Self>
[src]
impl<A> ParallelIterator for MultiZip<(A,)> where
A: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
type Item = (A::Item,)
The type of item that this parallel iterator produces.
For example, if you use the for_each
method, this is the type of
item that your closure will be invoked with. Read more
fn drive_unindexed<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result where
CONSUMER: UnindexedConsumer<Self::Item>,
[src]
CONSUMER: UnindexedConsumer<Self::Item>,
fn opt_len(&self) -> Option<usize>
[src]
fn for_each<OP>(self, op: OP) where
OP: Fn(Self::Item) + Sync + Send,
[src]
OP: Fn(Self::Item) + Sync + Send,
fn for_each_with<OP, T>(self, init: T, op: OP) where
OP: Fn(&mut T, Self::Item) + Sync + Send,
T: Send + Clone,
[src]
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,
[src]
OP: Fn(&mut T, Self::Item) + Sync + Send,
INIT: Fn() -> T + Sync + Send,
fn try_for_each<OP, R>(self, op: OP) -> R where
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
[src]
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
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]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Try<Ok = ()> + Send,
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]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Try<Ok = ()> + Send,
fn count(self) -> usize
[src]
fn map<F, R>(self, map_op: F) -> Map<Self, F> where
F: Fn(Self::Item) -> R + Sync + Send,
R: Send,
[src]
F: Fn(Self::Item) -> R + Sync + Send,
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,
[src]
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
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,
[src]
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 cloned<'a, T>(self) -> Cloned<Self> where
T: 'a + Clone + Send,
Self: ParallelIterator<Item = &'a T>,
[src]
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>,
[src]
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,
[src]
OP: Fn(&Self::Item) + Sync + Send,
fn update<F>(self, update_op: F) -> Update<Self, F> where
F: Fn(&mut Self::Item) + Sync + Send,
[src]
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,
[src]
P: Fn(&Self::Item) -> bool + Sync + Send,
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
[src]
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
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]
F: Fn(Self::Item) -> SI + Sync + Send,
SI: IntoIterator,
SI::Item: Send,
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoParallelIterator,
[src]
Self::Item: IntoParallelIterator,
fn flatten_iter(self) -> FlattenIter<Self> where
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
[src]
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
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]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
ID: Fn() -> 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,
[src]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
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]
OP: Fn(T, T) -> Self::Item + Sync + Send,
ID: Fn() -> T + Sync + Send,
Self::Item: Try<Ok = T>,
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]
OP: Fn(T, T) -> Self::Item + Sync + Send,
Self::Item: Try<Ok = T>,
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]
F: Fn(T, Self::Item) -> T + Sync + Send,
ID: Fn() -> T + Sync + Send,
T: Send,
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]
F: Fn(T, Self::Item) -> T + Sync + Send,
T: Send + Clone,
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]
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,
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]
F: Fn(T, Self::Item) -> R + Sync + Send,
R: Try<Ok = T> + Send,
T: Clone + Send,
fn sum<S>(self) -> S where
S: Send + Sum<Self::Item> + Sum<S>,
[src]
S: Send + Sum<Self::Item> + Sum<S>,
fn product<P>(self) -> P where
P: Send + Product<Self::Item> + Product<P>,
[src]
P: Send + Product<Self::Item> + Product<P>,
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn min_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn max_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn chain<C>(self, chain: C) -> Chain<Self, C::Iter> where
C: IntoParallelIterator<Item = Self::Item>,
[src]
C: IntoParallelIterator<Item = Self::Item>,
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn any<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn all<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn while_some<T>(self) -> WhileSome<Self> where
Self: ParallelIterator<Item = Option<T>>,
T: Send,
[src]
Self: ParallelIterator<Item = Option<T>>,
T: Send,
fn panic_fuse(self) -> PanicFuse<Self>
[src]
fn collect<C>(self) -> C where
C: FromParallelIterator<Self::Item>,
[src]
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,
[src]
Self: ParallelIterator<Item = (A, B)>,
FromA: Default + Send + ParallelExtend<A>,
FromB: Default + Send + ParallelExtend<B>,
A: Send,
B: 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,
[src]
A: Default + Send + ParallelExtend<Self::Item>,
B: Default + Send + ParallelExtend<Self::Item>,
P: Fn(&Self::Item) -> bool + Sync + 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,
[src]
A: Default + Send + ParallelExtend<L>,
B: Default + Send + ParallelExtend<R>,
P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
L: Send,
R: Send,
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]
Self::Item: Clone,
impl<A, B> ParallelIterator for MultiZip<(A, B)> where
A: IndexedParallelIterator,
B: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator,
type Item = (A::Item, B::Item)
The type of item that this parallel iterator produces.
For example, if you use the for_each
method, this is the type of
item that your closure will be invoked with. Read more
fn drive_unindexed<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result where
CONSUMER: UnindexedConsumer<Self::Item>,
[src]
CONSUMER: UnindexedConsumer<Self::Item>,
fn opt_len(&self) -> Option<usize>
[src]
fn for_each<OP>(self, op: OP) where
OP: Fn(Self::Item) + Sync + Send,
[src]
OP: Fn(Self::Item) + Sync + Send,
fn for_each_with<OP, T>(self, init: T, op: OP) where
OP: Fn(&mut T, Self::Item) + Sync + Send,
T: Send + Clone,
[src]
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,
[src]
OP: Fn(&mut T, Self::Item) + Sync + Send,
INIT: Fn() -> T + Sync + Send,
fn try_for_each<OP, R>(self, op: OP) -> R where
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
[src]
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
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]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Try<Ok = ()> + Send,
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]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Try<Ok = ()> + Send,
fn count(self) -> usize
[src]
fn map<F, R>(self, map_op: F) -> Map<Self, F> where
F: Fn(Self::Item) -> R + Sync + Send,
R: Send,
[src]
F: Fn(Self::Item) -> R + Sync + Send,
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,
[src]
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
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,
[src]
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 cloned<'a, T>(self) -> Cloned<Self> where
T: 'a + Clone + Send,
Self: ParallelIterator<Item = &'a T>,
[src]
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>,
[src]
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,
[src]
OP: Fn(&Self::Item) + Sync + Send,
fn update<F>(self, update_op: F) -> Update<Self, F> where
F: Fn(&mut Self::Item) + Sync + Send,
[src]
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,
[src]
P: Fn(&Self::Item) -> bool + Sync + Send,
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
[src]
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
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]
F: Fn(Self::Item) -> SI + Sync + Send,
SI: IntoIterator,
SI::Item: Send,
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoParallelIterator,
[src]
Self::Item: IntoParallelIterator,
fn flatten_iter(self) -> FlattenIter<Self> where
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
[src]
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
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]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
ID: Fn() -> 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,
[src]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
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]
OP: Fn(T, T) -> Self::Item + Sync + Send,
ID: Fn() -> T + Sync + Send,
Self::Item: Try<Ok = T>,
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]
OP: Fn(T, T) -> Self::Item + Sync + Send,
Self::Item: Try<Ok = T>,
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]
F: Fn(T, Self::Item) -> T + Sync + Send,
ID: Fn() -> T + Sync + Send,
T: Send,
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]
F: Fn(T, Self::Item) -> T + Sync + Send,
T: Send + Clone,
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]
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,
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]
F: Fn(T, Self::Item) -> R + Sync + Send,
R: Try<Ok = T> + Send,
T: Clone + Send,
fn sum<S>(self) -> S where
S: Send + Sum<Self::Item> + Sum<S>,
[src]
S: Send + Sum<Self::Item> + Sum<S>,
fn product<P>(self) -> P where
P: Send + Product<Self::Item> + Product<P>,
[src]
P: Send + Product<Self::Item> + Product<P>,
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn min_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn max_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn chain<C>(self, chain: C) -> Chain<Self, C::Iter> where
C: IntoParallelIterator<Item = Self::Item>,
[src]
C: IntoParallelIterator<Item = Self::Item>,
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn any<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn all<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn while_some<T>(self) -> WhileSome<Self> where
Self: ParallelIterator<Item = Option<T>>,
T: Send,
[src]
Self: ParallelIterator<Item = Option<T>>,
T: Send,
fn panic_fuse(self) -> PanicFuse<Self>
[src]
fn collect<C>(self) -> C where
C: FromParallelIterator<Self::Item>,
[src]
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,
[src]
Self: ParallelIterator<Item = (A, B)>,
FromA: Default + Send + ParallelExtend<A>,
FromB: Default + Send + ParallelExtend<B>,
A: Send,
B: 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,
[src]
A: Default + Send + ParallelExtend<Self::Item>,
B: Default + Send + ParallelExtend<Self::Item>,
P: Fn(&Self::Item) -> bool + Sync + 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,
[src]
A: Default + Send + ParallelExtend<L>,
B: Default + Send + ParallelExtend<R>,
P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
L: Send,
R: Send,
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]
Self::Item: Clone,
impl<A, B, C, D, E, F, G, H, I, J, K> ParallelIterator for MultiZip<(A, B, C, D, E, F, G, H, I, J, K)> where
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
G: IndexedParallelIterator,
H: IndexedParallelIterator,
I: IndexedParallelIterator,
J: IndexedParallelIterator,
K: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
G: IndexedParallelIterator,
H: IndexedParallelIterator,
I: IndexedParallelIterator,
J: IndexedParallelIterator,
K: IndexedParallelIterator,
type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item, J::Item, K::Item)
The type of item that this parallel iterator produces.
For example, if you use the for_each
method, this is the type of
item that your closure will be invoked with. Read more
fn drive_unindexed<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result where
CONSUMER: UnindexedConsumer<Self::Item>,
[src]
CONSUMER: UnindexedConsumer<Self::Item>,
fn opt_len(&self) -> Option<usize>
[src]
fn for_each<OP>(self, op: OP) where
OP: Fn(Self::Item) + Sync + Send,
[src]
OP: Fn(Self::Item) + Sync + Send,
fn for_each_with<OP, T>(self, init: T, op: OP) where
OP: Fn(&mut T, Self::Item) + Sync + Send,
T: Send + Clone,
[src]
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,
[src]
OP: Fn(&mut T, Self::Item) + Sync + Send,
INIT: Fn() -> T + Sync + Send,
fn try_for_each<OP, R>(self, op: OP) -> R where
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
[src]
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
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]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Try<Ok = ()> + Send,
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]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Try<Ok = ()> + Send,
fn count(self) -> usize
[src]
fn map<F, R>(self, map_op: F) -> Map<Self, F> where
F: Fn(Self::Item) -> R + Sync + Send,
R: Send,
[src]
F: Fn(Self::Item) -> R + Sync + Send,
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,
[src]
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
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,
[src]
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 cloned<'a, T>(self) -> Cloned<Self> where
T: 'a + Clone + Send,
Self: ParallelIterator<Item = &'a T>,
[src]
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>,
[src]
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,
[src]
OP: Fn(&Self::Item) + Sync + Send,
fn update<F>(self, update_op: F) -> Update<Self, F> where
F: Fn(&mut Self::Item) + Sync + Send,
[src]
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,
[src]
P: Fn(&Self::Item) -> bool + Sync + Send,
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
[src]
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
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]
F: Fn(Self::Item) -> SI + Sync + Send,
SI: IntoIterator,
SI::Item: Send,
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoParallelIterator,
[src]
Self::Item: IntoParallelIterator,
fn flatten_iter(self) -> FlattenIter<Self> where
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
[src]
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
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]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
ID: Fn() -> 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,
[src]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
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]
OP: Fn(T, T) -> Self::Item + Sync + Send,
ID: Fn() -> T + Sync + Send,
Self::Item: Try<Ok = T>,
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]
OP: Fn(T, T) -> Self::Item + Sync + Send,
Self::Item: Try<Ok = T>,
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]
F: Fn(T, Self::Item) -> T + Sync + Send,
ID: Fn() -> T + Sync + Send,
T: Send,
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]
F: Fn(T, Self::Item) -> T + Sync + Send,
T: Send + Clone,
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]
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,
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]
F: Fn(T, Self::Item) -> R + Sync + Send,
R: Try<Ok = T> + Send,
T: Clone + Send,
fn sum<S>(self) -> S where
S: Send + Sum<Self::Item> + Sum<S>,
[src]
S: Send + Sum<Self::Item> + Sum<S>,
fn product<P>(self) -> P where
P: Send + Product<Self::Item> + Product<P>,
[src]
P: Send + Product<Self::Item> + Product<P>,
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn min_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn max_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn chain<C>(self, chain: C) -> Chain<Self, C::Iter> where
C: IntoParallelIterator<Item = Self::Item>,
[src]
C: IntoParallelIterator<Item = Self::Item>,
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn any<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn all<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn while_some<T>(self) -> WhileSome<Self> where
Self: ParallelIterator<Item = Option<T>>,
T: Send,
[src]
Self: ParallelIterator<Item = Option<T>>,
T: Send,
fn panic_fuse(self) -> PanicFuse<Self>
[src]
fn collect<C>(self) -> C where
C: FromParallelIterator<Self::Item>,
[src]
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,
[src]
Self: ParallelIterator<Item = (A, B)>,
FromA: Default + Send + ParallelExtend<A>,
FromB: Default + Send + ParallelExtend<B>,
A: Send,
B: 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,
[src]
A: Default + Send + ParallelExtend<Self::Item>,
B: Default + Send + ParallelExtend<Self::Item>,
P: Fn(&Self::Item) -> bool + Sync + 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,
[src]
A: Default + Send + ParallelExtend<L>,
B: Default + Send + ParallelExtend<R>,
P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
L: Send,
R: Send,
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]
Self::Item: Clone,
impl<A, B, C, D, E, F, G, H, I, J, K, L> ParallelIterator for MultiZip<(A, B, C, D, E, F, G, H, I, J, K, L)> where
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
G: IndexedParallelIterator,
H: IndexedParallelIterator,
I: IndexedParallelIterator,
J: IndexedParallelIterator,
K: IndexedParallelIterator,
L: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
G: IndexedParallelIterator,
H: IndexedParallelIterator,
I: IndexedParallelIterator,
J: IndexedParallelIterator,
K: IndexedParallelIterator,
L: IndexedParallelIterator,
type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item, J::Item, K::Item, L::Item)
The type of item that this parallel iterator produces.
For example, if you use the for_each
method, this is the type of
item that your closure will be invoked with. Read more
fn drive_unindexed<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result where
CONSUMER: UnindexedConsumer<Self::Item>,
[src]
CONSUMER: UnindexedConsumer<Self::Item>,
fn opt_len(&self) -> Option<usize>
[src]
fn for_each<OP>(self, op: OP) where
OP: Fn(Self::Item) + Sync + Send,
[src]
OP: Fn(Self::Item) + Sync + Send,
fn for_each_with<OP, T>(self, init: T, op: OP) where
OP: Fn(&mut T, Self::Item) + Sync + Send,
T: Send + Clone,
[src]
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,
[src]
OP: Fn(&mut T, Self::Item) + Sync + Send,
INIT: Fn() -> T + Sync + Send,
fn try_for_each<OP, R>(self, op: OP) -> R where
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
[src]
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
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]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Try<Ok = ()> + Send,
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]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Try<Ok = ()> + Send,
fn count(self) -> usize
[src]
fn map<F, R>(self, map_op: F) -> Map<Self, F> where
F: Fn(Self::Item) -> R + Sync + Send,
R: Send,
[src]
F: Fn(Self::Item) -> R + Sync + Send,
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,
[src]
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
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,
[src]
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 cloned<'a, T>(self) -> Cloned<Self> where
T: 'a + Clone + Send,
Self: ParallelIterator<Item = &'a T>,
[src]
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>,
[src]
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,
[src]
OP: Fn(&Self::Item) + Sync + Send,
fn update<F>(self, update_op: F) -> Update<Self, F> where
F: Fn(&mut Self::Item) + Sync + Send,
[src]
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,
[src]
P: Fn(&Self::Item) -> bool + Sync + Send,
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
[src]
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
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]
F: Fn(Self::Item) -> SI + Sync + Send,
SI: IntoIterator,
SI::Item: Send,
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoParallelIterator,
[src]
Self::Item: IntoParallelIterator,
fn flatten_iter(self) -> FlattenIter<Self> where
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
[src]
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
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]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
ID: Fn() -> 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,
[src]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
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]
OP: Fn(T, T) -> Self::Item + Sync + Send,
ID: Fn() -> T + Sync + Send,
Self::Item: Try<Ok = T>,
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]
OP: Fn(T, T) -> Self::Item + Sync + Send,
Self::Item: Try<Ok = T>,
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]
F: Fn(T, Self::Item) -> T + Sync + Send,
ID: Fn() -> T + Sync + Send,
T: Send,
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]
F: Fn(T, Self::Item) -> T + Sync + Send,
T: Send + Clone,
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]
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,
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]
F: Fn(T, Self::Item) -> R + Sync + Send,
R: Try<Ok = T> + Send,
T: Clone + Send,
fn sum<S>(self) -> S where
S: Send + Sum<Self::Item> + Sum<S>,
[src]
S: Send + Sum<Self::Item> + Sum<S>,
fn product<P>(self) -> P where
P: Send + Product<Self::Item> + Product<P>,
[src]
P: Send + Product<Self::Item> + Product<P>,
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn min_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn max_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn chain<C>(self, chain: C) -> Chain<Self, C::Iter> where
C: IntoParallelIterator<Item = Self::Item>,
[src]
C: IntoParallelIterator<Item = Self::Item>,
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn any<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn all<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn while_some<T>(self) -> WhileSome<Self> where
Self: ParallelIterator<Item = Option<T>>,
T: Send,
[src]
Self: ParallelIterator<Item = Option<T>>,
T: Send,
fn panic_fuse(self) -> PanicFuse<Self>
[src]
fn collect<C>(self) -> C where
C: FromParallelIterator<Self::Item>,
[src]
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,
[src]
Self: ParallelIterator<Item = (A, B)>,
FromA: Default + Send + ParallelExtend<A>,
FromB: Default + Send + ParallelExtend<B>,
A: Send,
B: 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,
[src]
A: Default + Send + ParallelExtend<Self::Item>,
B: Default + Send + ParallelExtend<Self::Item>,
P: Fn(&Self::Item) -> bool + Sync + 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,
[src]
A: Default + Send + ParallelExtend<L>,
B: Default + Send + ParallelExtend<R>,
P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
L: Send,
R: Send,
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]
Self::Item: Clone,
impl<A, B, C> ParallelIterator for MultiZip<(A, B, C)> where
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
type Item = (A::Item, B::Item, C::Item)
The type of item that this parallel iterator produces.
For example, if you use the for_each
method, this is the type of
item that your closure will be invoked with. Read more
fn drive_unindexed<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result where
CONSUMER: UnindexedConsumer<Self::Item>,
[src]
CONSUMER: UnindexedConsumer<Self::Item>,
fn opt_len(&self) -> Option<usize>
[src]
fn for_each<OP>(self, op: OP) where
OP: Fn(Self::Item) + Sync + Send,
[src]
OP: Fn(Self::Item) + Sync + Send,
fn for_each_with<OP, T>(self, init: T, op: OP) where
OP: Fn(&mut T, Self::Item) + Sync + Send,
T: Send + Clone,
[src]
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,
[src]
OP: Fn(&mut T, Self::Item) + Sync + Send,
INIT: Fn() -> T + Sync + Send,
fn try_for_each<OP, R>(self, op: OP) -> R where
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
[src]
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
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]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Try<Ok = ()> + Send,
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]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Try<Ok = ()> + Send,
fn count(self) -> usize
[src]
fn map<F, R>(self, map_op: F) -> Map<Self, F> where
F: Fn(Self::Item) -> R + Sync + Send,
R: Send,
[src]
F: Fn(Self::Item) -> R + Sync + Send,
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,
[src]
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
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,
[src]
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 cloned<'a, T>(self) -> Cloned<Self> where
T: 'a + Clone + Send,
Self: ParallelIterator<Item = &'a T>,
[src]
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>,
[src]
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,
[src]
OP: Fn(&Self::Item) + Sync + Send,
fn update<F>(self, update_op: F) -> Update<Self, F> where
F: Fn(&mut Self::Item) + Sync + Send,
[src]
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,
[src]
P: Fn(&Self::Item) -> bool + Sync + Send,
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
[src]
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
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]
F: Fn(Self::Item) -> SI + Sync + Send,
SI: IntoIterator,
SI::Item: Send,
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoParallelIterator,
[src]
Self::Item: IntoParallelIterator,
fn flatten_iter(self) -> FlattenIter<Self> where
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
[src]
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
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]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
ID: Fn() -> 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,
[src]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
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]
OP: Fn(T, T) -> Self::Item + Sync + Send,
ID: Fn() -> T + Sync + Send,
Self::Item: Try<Ok = T>,
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]
OP: Fn(T, T) -> Self::Item + Sync + Send,
Self::Item: Try<Ok = T>,
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]
F: Fn(T, Self::Item) -> T + Sync + Send,
ID: Fn() -> T + Sync + Send,
T: Send,
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]
F: Fn(T, Self::Item) -> T + Sync + Send,
T: Send + Clone,
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]
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,
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]
F: Fn(T, Self::Item) -> R + Sync + Send,
R: Try<Ok = T> + Send,
T: Clone + Send,
fn sum<S>(self) -> S where
S: Send + Sum<Self::Item> + Sum<S>,
[src]
S: Send + Sum<Self::Item> + Sum<S>,
fn product<P>(self) -> P where
P: Send + Product<Self::Item> + Product<P>,
[src]
P: Send + Product<Self::Item> + Product<P>,
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn min_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn max_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn chain<C>(self, chain: C) -> Chain<Self, C::Iter> where
C: IntoParallelIterator<Item = Self::Item>,
[src]
C: IntoParallelIterator<Item = Self::Item>,
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn any<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn all<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn while_some<T>(self) -> WhileSome<Self> where
Self: ParallelIterator<Item = Option<T>>,
T: Send,
[src]
Self: ParallelIterator<Item = Option<T>>,
T: Send,
fn panic_fuse(self) -> PanicFuse<Self>
[src]
fn collect<C>(self) -> C where
C: FromParallelIterator<Self::Item>,
[src]
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,
[src]
Self: ParallelIterator<Item = (A, B)>,
FromA: Default + Send + ParallelExtend<A>,
FromB: Default + Send + ParallelExtend<B>,
A: Send,
B: 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,
[src]
A: Default + Send + ParallelExtend<Self::Item>,
B: Default + Send + ParallelExtend<Self::Item>,
P: Fn(&Self::Item) -> bool + Sync + 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,
[src]
A: Default + Send + ParallelExtend<L>,
B: Default + Send + ParallelExtend<R>,
P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
L: Send,
R: Send,
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]
Self::Item: Clone,
impl<A, B, C, D> ParallelIterator for MultiZip<(A, B, C, D)> where
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
type Item = (A::Item, B::Item, C::Item, D::Item)
The type of item that this parallel iterator produces.
For example, if you use the for_each
method, this is the type of
item that your closure will be invoked with. Read more
fn drive_unindexed<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result where
CONSUMER: UnindexedConsumer<Self::Item>,
[src]
CONSUMER: UnindexedConsumer<Self::Item>,
fn opt_len(&self) -> Option<usize>
[src]
fn for_each<OP>(self, op: OP) where
OP: Fn(Self::Item) + Sync + Send,
[src]
OP: Fn(Self::Item) + Sync + Send,
fn for_each_with<OP, T>(self, init: T, op: OP) where
OP: Fn(&mut T, Self::Item) + Sync + Send,
T: Send + Clone,
[src]
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,
[src]
OP: Fn(&mut T, Self::Item) + Sync + Send,
INIT: Fn() -> T + Sync + Send,
fn try_for_each<OP, R>(self, op: OP) -> R where
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
[src]
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
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]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Try<Ok = ()> + Send,
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]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Try<Ok = ()> + Send,
fn count(self) -> usize
[src]
fn map<F, R>(self, map_op: F) -> Map<Self, F> where
F: Fn(Self::Item) -> R + Sync + Send,
R: Send,
[src]
F: Fn(Self::Item) -> R + Sync + Send,
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,
[src]
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
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,
[src]
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 cloned<'a, T>(self) -> Cloned<Self> where
T: 'a + Clone + Send,
Self: ParallelIterator<Item = &'a T>,
[src]
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>,
[src]
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,
[src]
OP: Fn(&Self::Item) + Sync + Send,
fn update<F>(self, update_op: F) -> Update<Self, F> where
F: Fn(&mut Self::Item) + Sync + Send,
[src]
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,
[src]
P: Fn(&Self::Item) -> bool + Sync + Send,
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
[src]
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
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]
F: Fn(Self::Item) -> SI + Sync + Send,
SI: IntoIterator,
SI::Item: Send,
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoParallelIterator,
[src]
Self::Item: IntoParallelIterator,
fn flatten_iter(self) -> FlattenIter<Self> where
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
[src]
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
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]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
ID: Fn() -> 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,
[src]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
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]
OP: Fn(T, T) -> Self::Item + Sync + Send,
ID: Fn() -> T + Sync + Send,
Self::Item: Try<Ok = T>,
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]
OP: Fn(T, T) -> Self::Item + Sync + Send,
Self::Item: Try<Ok = T>,
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]
F: Fn(T, Self::Item) -> T + Sync + Send,
ID: Fn() -> T + Sync + Send,
T: Send,
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]
F: Fn(T, Self::Item) -> T + Sync + Send,
T: Send + Clone,
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]
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,
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]
F: Fn(T, Self::Item) -> R + Sync + Send,
R: Try<Ok = T> + Send,
T: Clone + Send,
fn sum<S>(self) -> S where
S: Send + Sum<Self::Item> + Sum<S>,
[src]
S: Send + Sum<Self::Item> + Sum<S>,
fn product<P>(self) -> P where
P: Send + Product<Self::Item> + Product<P>,
[src]
P: Send + Product<Self::Item> + Product<P>,
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn min_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn max_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn chain<C>(self, chain: C) -> Chain<Self, C::Iter> where
C: IntoParallelIterator<Item = Self::Item>,
[src]
C: IntoParallelIterator<Item = Self::Item>,
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn any<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn all<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn while_some<T>(self) -> WhileSome<Self> where
Self: ParallelIterator<Item = Option<T>>,
T: Send,
[src]
Self: ParallelIterator<Item = Option<T>>,
T: Send,
fn panic_fuse(self) -> PanicFuse<Self>
[src]
fn collect<C>(self) -> C where
C: FromParallelIterator<Self::Item>,
[src]
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,
[src]
Self: ParallelIterator<Item = (A, B)>,
FromA: Default + Send + ParallelExtend<A>,
FromB: Default + Send + ParallelExtend<B>,
A: Send,
B: 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,
[src]
A: Default + Send + ParallelExtend<Self::Item>,
B: Default + Send + ParallelExtend<Self::Item>,
P: Fn(&Self::Item) -> bool + Sync + 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,
[src]
A: Default + Send + ParallelExtend<L>,
B: Default + Send + ParallelExtend<R>,
P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
L: Send,
R: Send,
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]
Self::Item: Clone,
impl<A, B, C, D, E> ParallelIterator for MultiZip<(A, B, C, D, E)> where
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
type Item = (A::Item, B::Item, C::Item, D::Item, E::Item)
The type of item that this parallel iterator produces.
For example, if you use the for_each
method, this is the type of
item that your closure will be invoked with. Read more
fn drive_unindexed<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result where
CONSUMER: UnindexedConsumer<Self::Item>,
[src]
CONSUMER: UnindexedConsumer<Self::Item>,
fn opt_len(&self) -> Option<usize>
[src]
fn for_each<OP>(self, op: OP) where
OP: Fn(Self::Item) + Sync + Send,
[src]
OP: Fn(Self::Item) + Sync + Send,
fn for_each_with<OP, T>(self, init: T, op: OP) where
OP: Fn(&mut T, Self::Item) + Sync + Send,
T: Send + Clone,
[src]
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,
[src]
OP: Fn(&mut T, Self::Item) + Sync + Send,
INIT: Fn() -> T + Sync + Send,
fn try_for_each<OP, R>(self, op: OP) -> R where
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
[src]
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
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]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Try<Ok = ()> + Send,
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]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Try<Ok = ()> + Send,
fn count(self) -> usize
[src]
fn map<F, R>(self, map_op: F) -> Map<Self, F> where
F: Fn(Self::Item) -> R + Sync + Send,
R: Send,
[src]
F: Fn(Self::Item) -> R + Sync + Send,
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,
[src]
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
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,
[src]
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 cloned<'a, T>(self) -> Cloned<Self> where
T: 'a + Clone + Send,
Self: ParallelIterator<Item = &'a T>,
[src]
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>,
[src]
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,
[src]
OP: Fn(&Self::Item) + Sync + Send,
fn update<F>(self, update_op: F) -> Update<Self, F> where
F: Fn(&mut Self::Item) + Sync + Send,
[src]
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,
[src]
P: Fn(&Self::Item) -> bool + Sync + Send,
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
[src]
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
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]
F: Fn(Self::Item) -> SI + Sync + Send,
SI: IntoIterator,
SI::Item: Send,
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoParallelIterator,
[src]
Self::Item: IntoParallelIterator,
fn flatten_iter(self) -> FlattenIter<Self> where
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
[src]
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
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]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
ID: Fn() -> 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,
[src]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
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]
OP: Fn(T, T) -> Self::Item + Sync + Send,
ID: Fn() -> T + Sync + Send,
Self::Item: Try<Ok = T>,
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]
OP: Fn(T, T) -> Self::Item + Sync + Send,
Self::Item: Try<Ok = T>,
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]
F: Fn(T, Self::Item) -> T + Sync + Send,
ID: Fn() -> T + Sync + Send,
T: Send,
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]
F: Fn(T, Self::Item) -> T + Sync + Send,
T: Send + Clone,
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]
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,
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]
F: Fn(T, Self::Item) -> R + Sync + Send,
R: Try<Ok = T> + Send,
T: Clone + Send,
fn sum<S>(self) -> S where
S: Send + Sum<Self::Item> + Sum<S>,
[src]
S: Send + Sum<Self::Item> + Sum<S>,
fn product<P>(self) -> P where
P: Send + Product<Self::Item> + Product<P>,
[src]
P: Send + Product<Self::Item> + Product<P>,
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn min_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn max_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn chain<C>(self, chain: C) -> Chain<Self, C::Iter> where
C: IntoParallelIterator<Item = Self::Item>,
[src]
C: IntoParallelIterator<Item = Self::Item>,
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn any<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn all<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn while_some<T>(self) -> WhileSome<Self> where
Self: ParallelIterator<Item = Option<T>>,
T: Send,
[src]
Self: ParallelIterator<Item = Option<T>>,
T: Send,
fn panic_fuse(self) -> PanicFuse<Self>
[src]
fn collect<C>(self) -> C where
C: FromParallelIterator<Self::Item>,
[src]
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,
[src]
Self: ParallelIterator<Item = (A, B)>,
FromA: Default + Send + ParallelExtend<A>,
FromB: Default + Send + ParallelExtend<B>,
A: Send,
B: 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,
[src]
A: Default + Send + ParallelExtend<Self::Item>,
B: Default + Send + ParallelExtend<Self::Item>,
P: Fn(&Self::Item) -> bool + Sync + 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,
[src]
A: Default + Send + ParallelExtend<L>,
B: Default + Send + ParallelExtend<R>,
P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
L: Send,
R: Send,
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]
Self::Item: Clone,
impl<A, B, C, D, E, F> ParallelIterator for MultiZip<(A, B, C, D, E, F)> where
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item)
The type of item that this parallel iterator produces.
For example, if you use the for_each
method, this is the type of
item that your closure will be invoked with. Read more
fn drive_unindexed<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result where
CONSUMER: UnindexedConsumer<Self::Item>,
[src]
CONSUMER: UnindexedConsumer<Self::Item>,
fn opt_len(&self) -> Option<usize>
[src]
fn for_each<OP>(self, op: OP) where
OP: Fn(Self::Item) + Sync + Send,
[src]
OP: Fn(Self::Item) + Sync + Send,
fn for_each_with<OP, T>(self, init: T, op: OP) where
OP: Fn(&mut T, Self::Item) + Sync + Send,
T: Send + Clone,
[src]
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,
[src]
OP: Fn(&mut T, Self::Item) + Sync + Send,
INIT: Fn() -> T + Sync + Send,
fn try_for_each<OP, R>(self, op: OP) -> R where
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
[src]
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
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]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Try<Ok = ()> + Send,
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]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Try<Ok = ()> + Send,
fn count(self) -> usize
[src]
fn map<F, R>(self, map_op: F) -> Map<Self, F> where
F: Fn(Self::Item) -> R + Sync + Send,
R: Send,
[src]
F: Fn(Self::Item) -> R + Sync + Send,
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,
[src]
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
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,
[src]
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 cloned<'a, T>(self) -> Cloned<Self> where
T: 'a + Clone + Send,
Self: ParallelIterator<Item = &'a T>,
[src]
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>,
[src]
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,
[src]
OP: Fn(&Self::Item) + Sync + Send,
fn update<F>(self, update_op: F) -> Update<Self, F> where
F: Fn(&mut Self::Item) + Sync + Send,
[src]
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,
[src]
P: Fn(&Self::Item) -> bool + Sync + Send,
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
[src]
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
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]
F: Fn(Self::Item) -> SI + Sync + Send,
SI: IntoIterator,
SI::Item: Send,
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoParallelIterator,
[src]
Self::Item: IntoParallelIterator,
fn flatten_iter(self) -> FlattenIter<Self> where
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
[src]
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
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]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
ID: Fn() -> 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,
[src]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
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]
OP: Fn(T, T) -> Self::Item + Sync + Send,
ID: Fn() -> T + Sync + Send,
Self::Item: Try<Ok = T>,
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]
OP: Fn(T, T) -> Self::Item + Sync + Send,
Self::Item: Try<Ok = T>,
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]
F: Fn(T, Self::Item) -> T + Sync + Send,
ID: Fn() -> T + Sync + Send,
T: Send,
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]
F: Fn(T, Self::Item) -> T + Sync + Send,
T: Send + Clone,
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]
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,
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]
F: Fn(T, Self::Item) -> R + Sync + Send,
R: Try<Ok = T> + Send,
T: Clone + Send,
fn sum<S>(self) -> S where
S: Send + Sum<Self::Item> + Sum<S>,
[src]
S: Send + Sum<Self::Item> + Sum<S>,
fn product<P>(self) -> P where
P: Send + Product<Self::Item> + Product<P>,
[src]
P: Send + Product<Self::Item> + Product<P>,
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn min_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn max_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn chain<C>(self, chain: C) -> Chain<Self, C::Iter> where
C: IntoParallelIterator<Item = Self::Item>,
[src]
C: IntoParallelIterator<Item = Self::Item>,
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn any<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn all<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn while_some<T>(self) -> WhileSome<Self> where
Self: ParallelIterator<Item = Option<T>>,
T: Send,
[src]
Self: ParallelIterator<Item = Option<T>>,
T: Send,
fn panic_fuse(self) -> PanicFuse<Self>
[src]
fn collect<C>(self) -> C where
C: FromParallelIterator<Self::Item>,
[src]
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,
[src]
Self: ParallelIterator<Item = (A, B)>,
FromA: Default + Send + ParallelExtend<A>,
FromB: Default + Send + ParallelExtend<B>,
A: Send,
B: 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,
[src]
A: Default + Send + ParallelExtend<Self::Item>,
B: Default + Send + ParallelExtend<Self::Item>,
P: Fn(&Self::Item) -> bool + Sync + 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,
[src]
A: Default + Send + ParallelExtend<L>,
B: Default + Send + ParallelExtend<R>,
P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
L: Send,
R: Send,
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]
Self::Item: Clone,
impl<A, B, C, D, E, F, G> ParallelIterator for MultiZip<(A, B, C, D, E, F, G)> where
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
G: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
G: IndexedParallelIterator,
type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item)
The type of item that this parallel iterator produces.
For example, if you use the for_each
method, this is the type of
item that your closure will be invoked with. Read more
fn drive_unindexed<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result where
CONSUMER: UnindexedConsumer<Self::Item>,
[src]
CONSUMER: UnindexedConsumer<Self::Item>,
fn opt_len(&self) -> Option<usize>
[src]
fn for_each<OP>(self, op: OP) where
OP: Fn(Self::Item) + Sync + Send,
[src]
OP: Fn(Self::Item) + Sync + Send,
fn for_each_with<OP, T>(self, init: T, op: OP) where
OP: Fn(&mut T, Self::Item) + Sync + Send,
T: Send + Clone,
[src]
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,
[src]
OP: Fn(&mut T, Self::Item) + Sync + Send,
INIT: Fn() -> T + Sync + Send,
fn try_for_each<OP, R>(self, op: OP) -> R where
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
[src]
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
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]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Try<Ok = ()> + Send,
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]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Try<Ok = ()> + Send,
fn count(self) -> usize
[src]
fn map<F, R>(self, map_op: F) -> Map<Self, F> where
F: Fn(Self::Item) -> R + Sync + Send,
R: Send,
[src]
F: Fn(Self::Item) -> R + Sync + Send,
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,
[src]
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
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,
[src]
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 cloned<'a, T>(self) -> Cloned<Self> where
T: 'a + Clone + Send,
Self: ParallelIterator<Item = &'a T>,
[src]
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>,
[src]
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,
[src]
OP: Fn(&Self::Item) + Sync + Send,
fn update<F>(self, update_op: F) -> Update<Self, F> where
F: Fn(&mut Self::Item) + Sync + Send,
[src]
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,
[src]
P: Fn(&Self::Item) -> bool + Sync + Send,
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
[src]
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
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]
F: Fn(Self::Item) -> SI + Sync + Send,
SI: IntoIterator,
SI::Item: Send,
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoParallelIterator,
[src]
Self::Item: IntoParallelIterator,
fn flatten_iter(self) -> FlattenIter<Self> where
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
[src]
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
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]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
ID: Fn() -> 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,
[src]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
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]
OP: Fn(T, T) -> Self::Item + Sync + Send,
ID: Fn() -> T + Sync + Send,
Self::Item: Try<Ok = T>,
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]
OP: Fn(T, T) -> Self::Item + Sync + Send,
Self::Item: Try<Ok = T>,
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]
F: Fn(T, Self::Item) -> T + Sync + Send,
ID: Fn() -> T + Sync + Send,
T: Send,
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]
F: Fn(T, Self::Item) -> T + Sync + Send,
T: Send + Clone,
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]
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,
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]
F: Fn(T, Self::Item) -> R + Sync + Send,
R: Try<Ok = T> + Send,
T: Clone + Send,
fn sum<S>(self) -> S where
S: Send + Sum<Self::Item> + Sum<S>,
[src]
S: Send + Sum<Self::Item> + Sum<S>,
fn product<P>(self) -> P where
P: Send + Product<Self::Item> + Product<P>,
[src]
P: Send + Product<Self::Item> + Product<P>,
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn min_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn max_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn chain<C>(self, chain: C) -> Chain<Self, C::Iter> where
C: IntoParallelIterator<Item = Self::Item>,
[src]
C: IntoParallelIterator<Item = Self::Item>,
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn any<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn all<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn while_some<T>(self) -> WhileSome<Self> where
Self: ParallelIterator<Item = Option<T>>,
T: Send,
[src]
Self: ParallelIterator<Item = Option<T>>,
T: Send,
fn panic_fuse(self) -> PanicFuse<Self>
[src]
fn collect<C>(self) -> C where
C: FromParallelIterator<Self::Item>,
[src]
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,
[src]
Self: ParallelIterator<Item = (A, B)>,
FromA: Default + Send + ParallelExtend<A>,
FromB: Default + Send + ParallelExtend<B>,
A: Send,
B: 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,
[src]
A: Default + Send + ParallelExtend<Self::Item>,
B: Default + Send + ParallelExtend<Self::Item>,
P: Fn(&Self::Item) -> bool + Sync + 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,
[src]
A: Default + Send + ParallelExtend<L>,
B: Default + Send + ParallelExtend<R>,
P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
L: Send,
R: Send,
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]
Self::Item: Clone,
impl<A, B, C, D, E, F, G, H> ParallelIterator for MultiZip<(A, B, C, D, E, F, G, H)> where
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
G: IndexedParallelIterator,
H: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
G: IndexedParallelIterator,
H: IndexedParallelIterator,
type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item)
The type of item that this parallel iterator produces.
For example, if you use the for_each
method, this is the type of
item that your closure will be invoked with. Read more
fn drive_unindexed<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result where
CONSUMER: UnindexedConsumer<Self::Item>,
[src]
CONSUMER: UnindexedConsumer<Self::Item>,
fn opt_len(&self) -> Option<usize>
[src]
fn for_each<OP>(self, op: OP) where
OP: Fn(Self::Item) + Sync + Send,
[src]
OP: Fn(Self::Item) + Sync + Send,
fn for_each_with<OP, T>(self, init: T, op: OP) where
OP: Fn(&mut T, Self::Item) + Sync + Send,
T: Send + Clone,
[src]
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,
[src]
OP: Fn(&mut T, Self::Item) + Sync + Send,
INIT: Fn() -> T + Sync + Send,
fn try_for_each<OP, R>(self, op: OP) -> R where
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
[src]
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
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]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Try<Ok = ()> + Send,
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]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Try<Ok = ()> + Send,
fn count(self) -> usize
[src]
fn map<F, R>(self, map_op: F) -> Map<Self, F> where
F: Fn(Self::Item) -> R + Sync + Send,
R: Send,
[src]
F: Fn(Self::Item) -> R + Sync + Send,
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,
[src]
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
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,
[src]
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 cloned<'a, T>(self) -> Cloned<Self> where
T: 'a + Clone + Send,
Self: ParallelIterator<Item = &'a T>,
[src]
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>,
[src]
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,
[src]
OP: Fn(&Self::Item) + Sync + Send,
fn update<F>(self, update_op: F) -> Update<Self, F> where
F: Fn(&mut Self::Item) + Sync + Send,
[src]
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,
[src]
P: Fn(&Self::Item) -> bool + Sync + Send,
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
[src]
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
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]
F: Fn(Self::Item) -> SI + Sync + Send,
SI: IntoIterator,
SI::Item: Send,
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoParallelIterator,
[src]
Self::Item: IntoParallelIterator,
fn flatten_iter(self) -> FlattenIter<Self> where
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
[src]
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
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]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
ID: Fn() -> 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,
[src]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
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]
OP: Fn(T, T) -> Self::Item + Sync + Send,
ID: Fn() -> T + Sync + Send,
Self::Item: Try<Ok = T>,
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]
OP: Fn(T, T) -> Self::Item + Sync + Send,
Self::Item: Try<Ok = T>,
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]
F: Fn(T, Self::Item) -> T + Sync + Send,
ID: Fn() -> T + Sync + Send,
T: Send,
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]
F: Fn(T, Self::Item) -> T + Sync + Send,
T: Send + Clone,
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]
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,
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]
F: Fn(T, Self::Item) -> R + Sync + Send,
R: Try<Ok = T> + Send,
T: Clone + Send,
fn sum<S>(self) -> S where
S: Send + Sum<Self::Item> + Sum<S>,
[src]
S: Send + Sum<Self::Item> + Sum<S>,
fn product<P>(self) -> P where
P: Send + Product<Self::Item> + Product<P>,
[src]
P: Send + Product<Self::Item> + Product<P>,
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn min_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn max_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn chain<C>(self, chain: C) -> Chain<Self, C::Iter> where
C: IntoParallelIterator<Item = Self::Item>,
[src]
C: IntoParallelIterator<Item = Self::Item>,
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn any<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn all<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn while_some<T>(self) -> WhileSome<Self> where
Self: ParallelIterator<Item = Option<T>>,
T: Send,
[src]
Self: ParallelIterator<Item = Option<T>>,
T: Send,
fn panic_fuse(self) -> PanicFuse<Self>
[src]
fn collect<C>(self) -> C where
C: FromParallelIterator<Self::Item>,
[src]
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,
[src]
Self: ParallelIterator<Item = (A, B)>,
FromA: Default + Send + ParallelExtend<A>,
FromB: Default + Send + ParallelExtend<B>,
A: Send,
B: 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,
[src]
A: Default + Send + ParallelExtend<Self::Item>,
B: Default + Send + ParallelExtend<Self::Item>,
P: Fn(&Self::Item) -> bool + Sync + 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,
[src]
A: Default + Send + ParallelExtend<L>,
B: Default + Send + ParallelExtend<R>,
P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
L: Send,
R: Send,
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]
Self::Item: Clone,
impl<A, B, C, D, E, F, G, H, I> ParallelIterator for MultiZip<(A, B, C, D, E, F, G, H, I)> where
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
G: IndexedParallelIterator,
H: IndexedParallelIterator,
I: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
G: IndexedParallelIterator,
H: IndexedParallelIterator,
I: IndexedParallelIterator,
type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item)
The type of item that this parallel iterator produces.
For example, if you use the for_each
method, this is the type of
item that your closure will be invoked with. Read more
fn drive_unindexed<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result where
CONSUMER: UnindexedConsumer<Self::Item>,
[src]
CONSUMER: UnindexedConsumer<Self::Item>,
fn opt_len(&self) -> Option<usize>
[src]
fn for_each<OP>(self, op: OP) where
OP: Fn(Self::Item) + Sync + Send,
[src]
OP: Fn(Self::Item) + Sync + Send,
fn for_each_with<OP, T>(self, init: T, op: OP) where
OP: Fn(&mut T, Self::Item) + Sync + Send,
T: Send + Clone,
[src]
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,
[src]
OP: Fn(&mut T, Self::Item) + Sync + Send,
INIT: Fn() -> T + Sync + Send,
fn try_for_each<OP, R>(self, op: OP) -> R where
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
[src]
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
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]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Try<Ok = ()> + Send,
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]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Try<Ok = ()> + Send,
fn count(self) -> usize
[src]
fn map<F, R>(self, map_op: F) -> Map<Self, F> where
F: Fn(Self::Item) -> R + Sync + Send,
R: Send,
[src]
F: Fn(Self::Item) -> R + Sync + Send,
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,
[src]
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
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,
[src]
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 cloned<'a, T>(self) -> Cloned<Self> where
T: 'a + Clone + Send,
Self: ParallelIterator<Item = &'a T>,
[src]
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>,
[src]
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,
[src]
OP: Fn(&Self::Item) + Sync + Send,
fn update<F>(self, update_op: F) -> Update<Self, F> where
F: Fn(&mut Self::Item) + Sync + Send,
[src]
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,
[src]
P: Fn(&Self::Item) -> bool + Sync + Send,
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
[src]
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
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]
F: Fn(Self::Item) -> SI + Sync + Send,
SI: IntoIterator,
SI::Item: Send,
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoParallelIterator,
[src]
Self::Item: IntoParallelIterator,
fn flatten_iter(self) -> FlattenIter<Self> where
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
[src]
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
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]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
ID: Fn() -> 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,
[src]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
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]
OP: Fn(T, T) -> Self::Item + Sync + Send,
ID: Fn() -> T + Sync + Send,
Self::Item: Try<Ok = T>,
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]
OP: Fn(T, T) -> Self::Item + Sync + Send,
Self::Item: Try<Ok = T>,
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]
F: Fn(T, Self::Item) -> T + Sync + Send,
ID: Fn() -> T + Sync + Send,
T: Send,
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]
F: Fn(T, Self::Item) -> T + Sync + Send,
T: Send + Clone,
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]
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,
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]
F: Fn(T, Self::Item) -> R + Sync + Send,
R: Try<Ok = T> + Send,
T: Clone + Send,
fn sum<S>(self) -> S where
S: Send + Sum<Self::Item> + Sum<S>,
[src]
S: Send + Sum<Self::Item> + Sum<S>,
fn product<P>(self) -> P where
P: Send + Product<Self::Item> + Product<P>,
[src]
P: Send + Product<Self::Item> + Product<P>,
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn min_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn max_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn chain<C>(self, chain: C) -> Chain<Self, C::Iter> where
C: IntoParallelIterator<Item = Self::Item>,
[src]
C: IntoParallelIterator<Item = Self::Item>,
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn any<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn all<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn while_some<T>(self) -> WhileSome<Self> where
Self: ParallelIterator<Item = Option<T>>,
T: Send,
[src]
Self: ParallelIterator<Item = Option<T>>,
T: Send,
fn panic_fuse(self) -> PanicFuse<Self>
[src]
fn collect<C>(self) -> C where
C: FromParallelIterator<Self::Item>,
[src]
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,
[src]
Self: ParallelIterator<Item = (A, B)>,
FromA: Default + Send + ParallelExtend<A>,
FromB: Default + Send + ParallelExtend<B>,
A: Send,
B: 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,
[src]
A: Default + Send + ParallelExtend<Self::Item>,
B: Default + Send + ParallelExtend<Self::Item>,
P: Fn(&Self::Item) -> bool + Sync + 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,
[src]
A: Default + Send + ParallelExtend<L>,
B: Default + Send + ParallelExtend<R>,
P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
L: Send,
R: Send,
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]
Self::Item: Clone,
impl<A, B, C, D, E, F, G, H, I, J> ParallelIterator for MultiZip<(A, B, C, D, E, F, G, H, I, J)> where
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
G: IndexedParallelIterator,
H: IndexedParallelIterator,
I: IndexedParallelIterator,
J: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator,
C: IndexedParallelIterator,
D: IndexedParallelIterator,
E: IndexedParallelIterator,
F: IndexedParallelIterator,
G: IndexedParallelIterator,
H: IndexedParallelIterator,
I: IndexedParallelIterator,
J: IndexedParallelIterator,
type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item, J::Item)
The type of item that this parallel iterator produces.
For example, if you use the for_each
method, this is the type of
item that your closure will be invoked with. Read more
fn drive_unindexed<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result where
CONSUMER: UnindexedConsumer<Self::Item>,
[src]
CONSUMER: UnindexedConsumer<Self::Item>,
fn opt_len(&self) -> Option<usize>
[src]
fn for_each<OP>(self, op: OP) where
OP: Fn(Self::Item) + Sync + Send,
[src]
OP: Fn(Self::Item) + Sync + Send,
fn for_each_with<OP, T>(self, init: T, op: OP) where
OP: Fn(&mut T, Self::Item) + Sync + Send,
T: Send + Clone,
[src]
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,
[src]
OP: Fn(&mut T, Self::Item) + Sync + Send,
INIT: Fn() -> T + Sync + Send,
fn try_for_each<OP, R>(self, op: OP) -> R where
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
[src]
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
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]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Try<Ok = ()> + Send,
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]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Try<Ok = ()> + Send,
fn count(self) -> usize
[src]
fn map<F, R>(self, map_op: F) -> Map<Self, F> where
F: Fn(Self::Item) -> R + Sync + Send,
R: Send,
[src]
F: Fn(Self::Item) -> R + Sync + Send,
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,
[src]
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
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,
[src]
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 cloned<'a, T>(self) -> Cloned<Self> where
T: 'a + Clone + Send,
Self: ParallelIterator<Item = &'a T>,
[src]
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>,
[src]
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,
[src]
OP: Fn(&Self::Item) + Sync + Send,
fn update<F>(self, update_op: F) -> Update<Self, F> where
F: Fn(&mut Self::Item) + Sync + Send,
[src]
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,
[src]
P: Fn(&Self::Item) -> bool + Sync + Send,
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
[src]
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
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]
F: Fn(Self::Item) -> SI + Sync + Send,
SI: IntoIterator,
SI::Item: Send,
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoParallelIterator,
[src]
Self::Item: IntoParallelIterator,
fn flatten_iter(self) -> FlattenIter<Self> where
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
[src]
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
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]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
ID: Fn() -> 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,
[src]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
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]
OP: Fn(T, T) -> Self::Item + Sync + Send,
ID: Fn() -> T + Sync + Send,
Self::Item: Try<Ok = T>,
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]
OP: Fn(T, T) -> Self::Item + Sync + Send,
Self::Item: Try<Ok = T>,
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]
F: Fn(T, Self::Item) -> T + Sync + Send,
ID: Fn() -> T + Sync + Send,
T: Send,
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]
F: Fn(T, Self::Item) -> T + Sync + Send,
T: Send + Clone,
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]
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,
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]
F: Fn(T, Self::Item) -> R + Sync + Send,
R: Try<Ok = T> + Send,
T: Clone + Send,
fn sum<S>(self) -> S where
S: Send + Sum<Self::Item> + Sum<S>,
[src]
S: Send + Sum<Self::Item> + Sum<S>,
fn product<P>(self) -> P where
P: Send + Product<Self::Item> + Product<P>,
[src]
P: Send + Product<Self::Item> + Product<P>,
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn min_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn max_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn chain<C>(self, chain: C) -> Chain<Self, C::Iter> where
C: IntoParallelIterator<Item = Self::Item>,
[src]
C: IntoParallelIterator<Item = Self::Item>,
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn any<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn all<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn while_some<T>(self) -> WhileSome<Self> where
Self: ParallelIterator<Item = Option<T>>,
T: Send,
[src]
Self: ParallelIterator<Item = Option<T>>,
T: Send,
fn panic_fuse(self) -> PanicFuse<Self>
[src]
fn collect<C>(self) -> C where
C: FromParallelIterator<Self::Item>,
[src]
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,
[src]
Self: ParallelIterator<Item = (A, B)>,
FromA: Default + Send + ParallelExtend<A>,
FromB: Default + Send + ParallelExtend<B>,
A: Send,
B: 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,
[src]
A: Default + Send + ParallelExtend<Self::Item>,
B: Default + Send + ParallelExtend<Self::Item>,
P: Fn(&Self::Item) -> bool + Sync + 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,
[src]
A: Default + Send + ParallelExtend<L>,
B: Default + Send + ParallelExtend<R>,
P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
L: Send,
R: Send,
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]
Self::Item: Clone,
Auto Trait Implementations
impl<T> RefUnwindSafe for MultiZip<T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
impl<T> Send for MultiZip<T> where
T: Send,
T: Send,
impl<T> Sync for MultiZip<T> where
T: Sync,
T: Sync,
impl<T> Unpin for MultiZip<T> where
T: Unpin,
T: Unpin,
impl<T> UnwindSafe for MultiZip<T> where
T: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> IntoParallelIterator for T where
T: ParallelIterator,
[src]
T: ParallelIterator,
type Iter = T
The parallel iterator type that will be created.
type Item = <T as ParallelIterator>::Item
The type of item that the parallel iterator will produce.
pub fn into_par_iter(Self) -> T
[src]
impl<T> Pointable for T
[src]
pub const ALIGN: usize
[src]
type Init = T
The type for initializers.
pub unsafe fn init(init: <T as Pointable>::Init) -> usize
[src]
pub unsafe fn deref<'a>(ptr: usize) -> &'a T
[src]
pub unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
[src]
pub unsafe fn drop(ptr: usize)
[src]
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,