[−][src]Struct rayon::iter::Enumerate
Enumerate
is an iterator that returns the current count along with the element.
This struct is created by the enumerate()
method on IndexedParallelIterator
Trait Implementations
impl<I: Clone + IndexedParallelIterator> Clone for Enumerate<I>
[src]
impl<I: Debug + IndexedParallelIterator> Debug for Enumerate<I>
[src]
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>,
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 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 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<I> ParallelIterator for Enumerate<I> where
I: IndexedParallelIterator,
[src]
I: IndexedParallelIterator,
type Item = (usize, 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<C>(self, consumer: C) -> C::Result where
C: UnindexedConsumer<Self::Item>,
[src]
C: 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 flatten(self) -> Flatten<Self> where
Self::Item: IntoParallelIterator,
[src]
Self::Item: IntoParallelIterator,
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<I> RefUnwindSafe for Enumerate<I> where
I: RefUnwindSafe,
I: RefUnwindSafe,
impl<I> Send for Enumerate<I>
impl<I> Sync for Enumerate<I> where
I: Sync,
I: Sync,
impl<I> Unpin for Enumerate<I> where
I: Unpin,
I: Unpin,
impl<I> UnwindSafe for Enumerate<I> where
I: UnwindSafe,
I: 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,
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.
fn into_par_iter(Self) -> T
[src]
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
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.
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>,