Trait rayon::iter::IndexedParallelIterator [−][src]
An iterator that supports “random access” to its data, meaning that you can split it at arbitrary indices and draw data from those points.
Note: Not implemented for u64
, i64
, u128
, or i128
ranges
Required methods
fn len(&self) -> usize
[src]
Produces an exact count of how many items this iterator will produce, presuming no panic occurs.
Examples
use rayon::prelude::*; let par_iter = (0..100).into_par_iter().zip(vec![0; 10]); assert_eq!(par_iter.len(), 10); let vec: Vec<_> = par_iter.collect(); assert_eq!(vec.len(), 10);
fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> C::Result
[src]
Internal method used to define the behavior of this parallel iterator. You should not need to call this directly.
This method causes the iterator self
to start producing
items and to feed them to the consumer consumer
one by one.
It may split the consumer before doing so to create the
opportunity to produce in parallel. If a split does happen, it
will inform the consumer of the index where the split should
occur (unlike ParallelIterator::drive_unindexed()
).
See the README for more details on the internals of parallel iterators.
fn with_producer<CB: ProducerCallback<Self::Item>>(
self,
callback: CB
) -> CB::Output
[src]
self,
callback: CB
) -> CB::Output
Internal method used to define the behavior of this parallel iterator. You should not need to call this directly.
This method converts the iterator into a producer P and then
invokes callback.callback()
with P. Note that the type of
this producer is not defined as part of the API, since
callback
must be defined generically for all producers. This
allows the producer type to contain references; it also means
that parallel iterators can adjust that type without causing a
breaking change.
See the README for more details on the internals of parallel iterators.
Provided methods
fn collect_into_vec(self, target: &mut Vec<Self::Item>)
[src]
Collects the results of the iterator into the specified vector. The vector is always truncated before execution begins. If possible, reusing the vector across calls can lead to better performance since it reuses the same backing buffer.
Examples
use rayon::prelude::*; // any prior data will be truncated let mut vec = vec![-1, -2, -3]; (0..5).into_par_iter() .collect_into_vec(&mut vec); assert_eq!(vec, [0, 1, 2, 3, 4]);
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,
Unzips the results of the iterator into the specified vectors. The vectors are always truncated before execution begins. If possible, reusing the vectors across calls can lead to better performance since they reuse the same backing buffer.
Examples
use rayon::prelude::*; // any prior data will be truncated let mut left = vec![42; 10]; let mut right = vec![-1; 10]; (10..15).into_par_iter() .enumerate() .unzip_into_vecs(&mut left, &mut right); assert_eq!(left, [0, 1, 2, 3, 4]); assert_eq!(right, [10, 11, 12, 13, 14]);
fn zip<Z>(self, zip_op: Z) -> Zip<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
Iterates over tuples (A, B)
, where the items A
are from
this iterator and B
are from the iterator given as argument.
Like the zip
method on ordinary iterators, if the two
iterators are of unequal length, you only get the items they
have in common.
Examples
use rayon::prelude::*; let result: Vec<_> = (1..4) .into_par_iter() .zip(vec!['a', 'b', 'c']) .collect(); assert_eq!(result, [(1, 'a'), (2, 'b'), (3, 'c')]);
fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, Z::Iter> where
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
[src]
Z: IntoParallelIterator,
Z::Iter: IndexedParallelIterator,
The same as Zip
, but requires that both iterators have the same length.
Panics
Will panic if self
and zip_op
are not the same length.
use rayon::prelude::*; let one = [1u8]; let two = [2u8, 2]; let one_iter = one.par_iter(); let two_iter = two.par_iter(); // this will panic let zipped: Vec<(&u8, &u8)> = one_iter.zip_eq(two_iter).collect(); // we should never get here assert_eq!(1, zipped.len());
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>,
Interleaves elements of this iterator and the other given iterator. Alternately yields elements from this iterator and the given iterator, until both are exhausted. If one iterator is exhausted before the other, the last elements are provided from the other.
Examples
use rayon::prelude::*; let (x, y) = (vec![1, 2], vec![3, 4, 5, 6]); let r: Vec<i32> = x.into_par_iter().interleave(y).collect(); assert_eq!(r, vec![1, 3, 2, 4, 5, 6]);
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>,
Interleaves elements of this iterator and the other given iterator, until one is exhausted.
Examples
use rayon::prelude::*; let (x, y) = (vec![1, 2, 3, 4], vec![5, 6]); let r: Vec<i32> = x.into_par_iter().interleave_shortest(y).collect(); assert_eq!(r, vec![1, 5, 2, 6, 3]);
fn chunks(self, chunk_size: usize) -> Chunks<Self>
[src]
Splits an iterator up into fixed-size chunks.
Returns an iterator that returns Vec
s of the given number of elements.
If the number of elements in the iterator is not divisible by chunk_size
,
the last chunk may be shorter than chunk_size
.
See also par_chunks()
and par_chunks_mut()
for similar behavior on
slices, without having to allocate intermediate Vec
s for the chunks.
Examples
use rayon::prelude::*; let a = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; let r: Vec<Vec<i32>> = a.into_par_iter().chunks(3).collect(); assert_eq!(r, vec![vec![1,2,3], vec![4,5,6], vec![7,8,9], vec![10]]);
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,
Lexicographically compares the elements of this ParallelIterator
with those of
another.
Examples
use rayon::prelude::*; use std::cmp::Ordering::*; let x = vec![1, 2, 3]; assert_eq!(x.par_iter().cmp(&vec![1, 3, 0]), Less); assert_eq!(x.par_iter().cmp(&vec![1, 2, 3]), Equal); assert_eq!(x.par_iter().cmp(&vec![1, 2]), Greater);
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>,
Lexicographically compares the elements of this ParallelIterator
with those of
another.
Examples
use rayon::prelude::*; use std::cmp::Ordering::*; use std::f64::NAN; let x = vec![1.0, 2.0, 3.0]; assert_eq!(x.par_iter().partial_cmp(&vec![1.0, 3.0, 0.0]), Some(Less)); assert_eq!(x.par_iter().partial_cmp(&vec![1.0, 2.0, 3.0]), Some(Equal)); assert_eq!(x.par_iter().partial_cmp(&vec![1.0, 2.0]), Some(Greater)); assert_eq!(x.par_iter().partial_cmp(&vec![1.0, NAN]), None);
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>,
Determines if the elements of this ParallelIterator
are equal to those of another
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>,
Determines if the elements of this ParallelIterator
are unequal to those of another
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>,
Determines if the elements of this ParallelIterator
are lexicographically less than those of another.
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>,
Determines if the elements of this ParallelIterator
are less or equal to those of another.
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>,
Determines if the elements of this ParallelIterator
are lexicographically greater than those of another.
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>,
Determines if the elements of this ParallelIterator
are less or equal to those of another.
fn enumerate(self) -> Enumerate<Self>
[src]
Yields an index along with each item.
Examples
use rayon::prelude::*; let chars = vec!['a', 'b', 'c']; let result: Vec<_> = chars .into_par_iter() .enumerate() .collect(); assert_eq!(result, [(0, 'a'), (1, 'b'), (2, 'c')]);
fn step_by(self, step: usize) -> StepBy<Self>
[src]
Creates an iterator that steps by the given amount
Examples
use rayon::prelude::*; let range = (3..10); let result: Vec<i32> = range .into_par_iter() .step_by(3) .collect(); assert_eq!(result, [3, 6, 9])
Compatibility
This method is only available on Rust 1.38 or greater.
fn skip(self, n: usize) -> Skip<Self>
[src]
Creates an iterator that skips the first n
elements.
Examples
use rayon::prelude::*; let result: Vec<_> = (0..100) .into_par_iter() .skip(95) .collect(); assert_eq!(result, [95, 96, 97, 98, 99]);
fn take(self, n: usize) -> Take<Self>
[src]
Creates an iterator that yields the first n
elements.
Examples
use rayon::prelude::*; let result: Vec<_> = (0..100) .into_par_iter() .take(5) .collect(); assert_eq!(result, [0, 1, 2, 3, 4]);
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,
Searches for some item in the parallel iterator that
matches the given predicate, and returns its index. Like
ParallelIterator::find_any
, the parallel search will not
necessarily find the first match, and once a match is
found we’ll attempt to stop processing any more.
Examples
use rayon::prelude::*; let a = [1, 2, 3, 3]; let i = a.par_iter().position_any(|&x| x == 3).expect("found"); assert!(i == 2 || i == 3); assert_eq!(a.par_iter().position_any(|&x| x == 100), None);
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,
Searches for the sequentially first item in the parallel iterator that matches the given predicate, and returns its index.
Like ParallelIterator::find_first
, once a match is found,
all attempts to the right of the match will be stopped, while
attempts to the left must continue in case an earlier match
is found.
Note that not all parallel iterators have a useful order, much like
sequential HashMap
iteration, so “first” may be nebulous. If you
just want the first match that discovered anywhere in the iterator,
position_any
is a better choice.
Examples
use rayon::prelude::*; let a = [1, 2, 3, 3]; assert_eq!(a.par_iter().position_first(|&x| x == 3), Some(2)); assert_eq!(a.par_iter().position_first(|&x| x == 100), None);
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,
Searches for the sequentially last item in the parallel iterator that matches the given predicate, and returns its index.
Like ParallelIterator::find_last
, once a match is found,
all attempts to the left of the match will be stopped, while
attempts to the right must continue in case a later match
is found.
Note that not all parallel iterators have a useful order, much like
sequential HashMap
iteration, so “last” may be nebulous. When the
order doesn’t actually matter to you, position_any
is a better
choice.
Examples
use rayon::prelude::*; let a = [1, 2, 3, 3]; assert_eq!(a.par_iter().position_last(|&x| x == 3), Some(3)); assert_eq!(a.par_iter().position_last(|&x| x == 100), None);
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,
Searches for items in the parallel iterator that match the given predicate, and returns their indices.
Examples
use rayon::prelude::*; let primes = vec![2, 3, 5, 7, 11, 13, 17, 19, 23, 29]; // Find the positions of primes congruent to 1 modulo 6 let p1mod6: Vec<_> = primes.par_iter().positions(|&p| p % 6 == 1).collect(); assert_eq!(p1mod6, [3, 5, 7]); // primes 7, 13, and 19 // Find the positions of primes congruent to 5 modulo 6 let p5mod6: Vec<_> = primes.par_iter().positions(|&p| p % 6 == 5).collect(); assert_eq!(p5mod6, [2, 4, 6, 8, 9]); // primes 5, 11, 17, 23, and 29
fn rev(self) -> Rev<Self>
[src]
Produces a new iterator with the elements of this iterator in reverse order.
Examples
use rayon::prelude::*; let result: Vec<_> = (0..5) .into_par_iter() .rev() .collect(); assert_eq!(result, [4, 3, 2, 1, 0]);
fn with_min_len(self, min: usize) -> MinLen<Self>
[src]
Sets the minimum length of iterators desired to process in each thread. Rayon will not split any smaller than this length, but of course an iterator could already be smaller to begin with.
Producers like zip
and interleave
will use greater of the two
minimums.
Chained iterators and iterators inside flat_map
may each use
their own minimum length.
Examples
use rayon::prelude::*; let min = (0..1_000_000) .into_par_iter() .with_min_len(1234) .fold(|| 0, |acc, _| acc + 1) // count how many are in this segment .min().unwrap(); assert!(min >= 1234);
fn with_max_len(self, max: usize) -> MaxLen<Self>
[src]
Sets the maximum length of iterators desired to process in each
thread. Rayon will try to split at least below this length,
unless that would put it below the length from with_min_len()
.
For example, given min=10 and max=15, a length of 16 will not be
split any further.
Producers like zip
and interleave
will use lesser of the two
maximums.
Chained iterators and iterators inside flat_map
may each use
their own maximum length.
Examples
use rayon::prelude::*; let max = (0..1_000_000) .into_par_iter() .with_max_len(1234) .fold(|| 0, |acc, _| acc + 1) // count how many are in this segment .max().unwrap(); assert!(max <= 1234);
Implementors
impl IndexedParallelIterator for rayon::range::Iter<char>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl IndexedParallelIterator for rayon::range::Iter<i8>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl IndexedParallelIterator for rayon::range::Iter<i16>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl IndexedParallelIterator for rayon::range::Iter<i32>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl IndexedParallelIterator for rayon::range::Iter<isize>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl IndexedParallelIterator for rayon::range::Iter<u8>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl IndexedParallelIterator for rayon::range::Iter<u16>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl IndexedParallelIterator for rayon::range::Iter<u32>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl IndexedParallelIterator for rayon::range::Iter<usize>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl IndexedParallelIterator for rayon::range_inclusive::Iter<char>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl IndexedParallelIterator for rayon::range_inclusive::Iter<i8>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl IndexedParallelIterator for rayon::range_inclusive::Iter<i16>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl IndexedParallelIterator for rayon::range_inclusive::Iter<u8>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl IndexedParallelIterator for rayon::range_inclusive::Iter<u16>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<'a, T, I> IndexedParallelIterator for Cloned<I> where
I: IndexedParallelIterator<Item = &'a T>,
T: 'a + Clone + Send + Sync,
[src]
I: IndexedParallelIterator<Item = &'a T>,
T: 'a + Clone + Send + Sync,
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<'a, T, I> IndexedParallelIterator for Copied<I> where
I: IndexedParallelIterator<Item = &'a T>,
T: 'a + Copy + Send + Sync,
[src]
I: IndexedParallelIterator<Item = &'a T>,
T: 'a + Copy + Send + Sync,
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<'a, T: Ord + Send> IndexedParallelIterator for rayon::collections::binary_heap::Drain<'a, T>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<'a, T: Ord + Sync + 'a> IndexedParallelIterator for rayon::collections::binary_heap::Iter<'a, T>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<'a, T: Send + 'a> IndexedParallelIterator for rayon::collections::vec_deque::IterMut<'a, T>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<'a, T: Send + 'a> IndexedParallelIterator for rayon::option::IterMut<'a, T>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<'a, T: Send + 'a> IndexedParallelIterator for rayon::result::IterMut<'a, T>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<'a, T: Send> IndexedParallelIterator for rayon::collections::vec_deque::Drain<'a, T>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<'a, T: Sync + 'a> IndexedParallelIterator for rayon::collections::vec_deque::Iter<'a, T>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<'a, T: Sync + 'a> IndexedParallelIterator for rayon::option::Iter<'a, T>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<'a, T: Sync + 'a> IndexedParallelIterator for rayon::result::Iter<'a, T>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<'data, T: Send + 'data> IndexedParallelIterator for ChunksExactMut<'data, T>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<'data, T: Send + 'data> IndexedParallelIterator for ChunksMut<'data, T>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<'data, T: Send + 'data> IndexedParallelIterator for rayon::slice::IterMut<'data, T>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<'data, T: Send> IndexedParallelIterator for rayon::vec::Drain<'data, T>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<'data, T: Sync + 'data> IndexedParallelIterator for rayon::slice::Chunks<'data, T>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<'data, T: Sync + 'data> IndexedParallelIterator for ChunksExact<'data, T>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<'data, T: Sync + 'data> IndexedParallelIterator for rayon::slice::Iter<'data, T>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<'data, T: Sync + 'data> IndexedParallelIterator for Windows<'data, T>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
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>,
impl<A, B> IndexedParallelIterator for Chain<A, B> where
A: IndexedParallelIterator,
B: IndexedParallelIterator<Item = A::Item>,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator<Item = A::Item>,
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
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>,
impl<A, B> IndexedParallelIterator for Zip<A, B> where
A: IndexedParallelIterator,
B: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator,
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<A, B> IndexedParallelIterator for ZipEq<A, B> where
A: IndexedParallelIterator,
B: IndexedParallelIterator,
[src]
A: IndexedParallelIterator,
B: IndexedParallelIterator,
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
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>,
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>,
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>,
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>,
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>,
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>,
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>,
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>,
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>,
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>,
impl<I> IndexedParallelIterator for rayon::iter::Chunks<I> where
I: IndexedParallelIterator,
[src]
I: IndexedParallelIterator,
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<I> IndexedParallelIterator for Enumerate<I> where
I: IndexedParallelIterator,
[src]
I: IndexedParallelIterator,
fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> C::Result
[src]
fn len(&self) -> usize
[src]
fn with_producer<CB>(self, callback: CB) -> CB::Output where
CB: ProducerCallback<Self::Item>,
[src]
CB: ProducerCallback<Self::Item>,
impl<I> IndexedParallelIterator for Intersperse<I> where
I: IndexedParallelIterator,
I::Item: Clone + Send,
[src]
I: IndexedParallelIterator,
I::Item: Clone + Send,
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<I> IndexedParallelIterator for MaxLen<I> where
I: IndexedParallelIterator,
[src]
I: IndexedParallelIterator,
fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> C::Result
[src]
fn len(&self) -> usize
[src]
fn with_producer<CB>(self, callback: CB) -> CB::Output where
CB: ProducerCallback<Self::Item>,
[src]
CB: ProducerCallback<Self::Item>,
impl<I> IndexedParallelIterator for MinLen<I> where
I: IndexedParallelIterator,
[src]
I: IndexedParallelIterator,
fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> C::Result
[src]
fn len(&self) -> usize
[src]
fn with_producer<CB>(self, callback: CB) -> CB::Output where
CB: ProducerCallback<Self::Item>,
[src]
CB: ProducerCallback<Self::Item>,
impl<I> IndexedParallelIterator for PanicFuse<I> where
I: IndexedParallelIterator,
[src]
I: IndexedParallelIterator,
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<I> IndexedParallelIterator for Rev<I> where
I: IndexedParallelIterator,
[src]
I: IndexedParallelIterator,
fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> C::Result
[src]
fn len(&self) -> usize
[src]
fn with_producer<CB>(self, callback: CB) -> CB::Output where
CB: ProducerCallback<Self::Item>,
[src]
CB: ProducerCallback<Self::Item>,
impl<I> IndexedParallelIterator for Skip<I> where
I: IndexedParallelIterator,
[src]
I: IndexedParallelIterator,
fn len(&self) -> usize
[src]
fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> C::Result
[src]
fn with_producer<CB>(self, callback: CB) -> CB::Output where
CB: ProducerCallback<Self::Item>,
[src]
CB: ProducerCallback<Self::Item>,
impl<I> IndexedParallelIterator for StepBy<I> where
I: IndexedParallelIterator,
[src]
I: IndexedParallelIterator,
fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> C::Result
[src]
fn len(&self) -> usize
[src]
fn with_producer<CB>(self, callback: CB) -> CB::Output where
CB: ProducerCallback<Self::Item>,
[src]
CB: ProducerCallback<Self::Item>,
impl<I> IndexedParallelIterator for Take<I> where
I: IndexedParallelIterator,
[src]
I: IndexedParallelIterator,
fn len(&self) -> usize
[src]
fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> C::Result
[src]
fn with_producer<CB>(self, callback: CB) -> CB::Output where
CB: ProducerCallback<Self::Item>,
[src]
CB: ProducerCallback<Self::Item>,
impl<I, F> IndexedParallelIterator for Inspect<I, F> where
I: IndexedParallelIterator,
F: Fn(&I::Item) + Sync + Send,
[src]
I: IndexedParallelIterator,
F: Fn(&I::Item) + Sync + Send,
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<I, F> IndexedParallelIterator for Update<I, F> where
I: IndexedParallelIterator,
F: Fn(&mut I::Item) + Send + Sync,
[src]
I: IndexedParallelIterator,
F: Fn(&mut I::Item) + Send + Sync,
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<I, F, R> IndexedParallelIterator for Map<I, F> where
I: IndexedParallelIterator,
F: Fn(I::Item) -> R + Sync + Send,
R: Send,
[src]
I: IndexedParallelIterator,
F: Fn(I::Item) -> R + Sync + Send,
R: Send,
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<I, INIT, T, F, R> IndexedParallelIterator for MapInit<I, INIT, F> where
I: IndexedParallelIterator,
INIT: Fn() -> T + Sync + Send,
F: Fn(&mut T, I::Item) -> R + Sync + Send,
R: Send,
[src]
I: IndexedParallelIterator,
INIT: Fn() -> T + Sync + Send,
F: Fn(&mut T, I::Item) -> R + Sync + Send,
R: Send,
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<I, J> IndexedParallelIterator for Interleave<I, J> where
I: IndexedParallelIterator,
J: IndexedParallelIterator<Item = I::Item>,
[src]
I: IndexedParallelIterator,
J: IndexedParallelIterator<Item = I::Item>,
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<I, J> IndexedParallelIterator for InterleaveShortest<I, J> where
I: IndexedParallelIterator,
J: IndexedParallelIterator<Item = I::Item>,
[src]
I: IndexedParallelIterator,
J: IndexedParallelIterator<Item = I::Item>,
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<I, T, F, R> IndexedParallelIterator for MapWith<I, T, F> where
I: IndexedParallelIterator,
T: Send + Clone,
F: Fn(&mut T, I::Item) -> R + Sync + Send,
R: Send,
[src]
I: IndexedParallelIterator,
T: Send + Clone,
F: Fn(&mut T, I::Item) -> R + Sync + Send,
R: Send,
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<L, R> IndexedParallelIterator for Either<L, R> where
L: IndexedParallelIterator,
R: IndexedParallelIterator<Item = L::Item>,
[src]
L: IndexedParallelIterator,
R: IndexedParallelIterator<Item = L::Item>,
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<T> IndexedParallelIterator for RepeatN<T> where
T: Clone + Send,
[src]
T: Clone + Send,
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: Consumer<Self::Item>,
fn with_producer<CB>(self, callback: CB) -> CB::Output where
CB: ProducerCallback<Self::Item>,
[src]
CB: ProducerCallback<Self::Item>,
fn len(&self) -> usize
[src]
impl<T: Ord + Send> IndexedParallelIterator for rayon::collections::binary_heap::IntoIter<T>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<T: Send> IndexedParallelIterator for rayon::collections::vec_deque::IntoIter<T>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<T: Send> IndexedParallelIterator for Empty<T>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<T: Send> IndexedParallelIterator for Once<T>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<T: Send> IndexedParallelIterator for rayon::option::IntoIter<T>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,
impl<T: Send> IndexedParallelIterator for rayon::result::IntoIter<T>
[src]
fn drive<C>(self, consumer: C) -> C::Result where
C: Consumer<Self::Item>,
[src]
C: 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>,