[−][src]Struct rayon::collections::linked_list::IntoIter
Parallel iterator over a linked list
Trait Implementations
impl<T: Send> ParallelIterator for IntoIter<T>
[src]
type Item = T
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,
Executes OP
on each item produced by the iterator, in parallel. Read more
fn for_each_with<OP, T>(self, init: T, op: OP) where
OP: Fn(&mut T, Self::Item) + Sync + Send,
T: Send + Clone,
[src]
OP: Fn(&mut T, Self::Item) + Sync + Send,
T: Send + Clone,
Executes OP
on the given init
value with each item produced by the iterator, in parallel. Read more
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
OP: Fn(&mut T, Self::Item) + Sync + Send,
INIT: Fn() -> T + Sync + Send,
[src]
OP: Fn(&mut T, Self::Item) + Sync + Send,
INIT: Fn() -> T + Sync + Send,
Executes OP
on a value returned by init
with each item produced by the iterator, in parallel. Read more
fn try_for_each<OP, R>(self, op: OP) -> R where
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
[src]
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
Executes a fallible OP
on each item produced by the iterator, in parallel. Read more
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Try<Ok = ()> + Send,
[src]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Try<Ok = ()> + Send,
Executes a fallible OP
on the given init
value with each item produced by the iterator, in parallel. Read more
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Try<Ok = ()> + Send,
[src]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Try<Ok = ()> + Send,
Executes a fallible OP
on a value returned by init
with each item produced by the iterator, in parallel. Read more
fn count(self) -> usize
[src]
Counts the number of items in this parallel iterator. Read more
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,
Applies map_op
to each item of this iterator, producing a new iterator with the results. Read more
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Send,
[src]
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Send,
Applies map_op
to the given init
value with each item of this iterator, producing a new iterator with the results. Read more
fn map_init<F, INIT, T, R>(
self,
init: INIT,
map_op: F
) -> MapInit<Self, INIT, F> where
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Send,
[src]
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,
Applies map_op
to a value returned by init
with each item of this iterator, producing a new iterator with the results. Read more
fn cloned<'a, T>(self) -> Cloned<Self> where
T: 'a + Clone + Send,
Self: ParallelIterator<Item = &'a T>,
[src]
T: 'a + Clone + Send,
Self: ParallelIterator<Item = &'a T>,
Creates an iterator which clones all of its elements. This may be useful when you have an iterator over &T
, but you need T
, and that type implements Clone
. See also [copied()
]. Read more
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>,
Creates an iterator which copies all of its elements. This may be useful when you have an iterator over &T
, but you need T
, and that type implements Copy
. See also [cloned()
]. Read more
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
OP: Fn(&Self::Item) + Sync + Send,
[src]
OP: Fn(&Self::Item) + Sync + Send,
Applies inspect_op
to a reference to each item of this iterator, producing a new iterator passing through the original items. This is often useful for debugging to see what's happening in iterator stages. Read more
fn update<F>(self, update_op: F) -> Update<Self, F> where
F: Fn(&mut Self::Item) + Sync + Send,
[src]
F: Fn(&mut Self::Item) + Sync + Send,
Mutates each item of this iterator before yielding it. Read more
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
P: Fn(&Self::Item) -> bool + Sync + Send,
Applies filter_op
to each item of this iterator, producing a new iterator with only the items that gave true
results. Read more
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
Applies filter_op
to each item of this iterator to get an Option
, producing a new iterator with only the items from Some
results. Read more
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
[src]
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
Applies map_op
to each item of this iterator to get nested iterators, producing a new iterator that flattens these back into one. Read more
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoParallelIterator,
[src]
Self::Item: IntoParallelIterator,
An adaptor that flattens iterable Item
s into one large iterator Read more
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
ID: Fn() -> Self::Item + Sync + Send,
[src]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
ID: Fn() -> Self::Item + Sync + Send,
Reduces the items in the iterator into one item using op
. The argument identity
should be a closure that can produce "identity" value which may be inserted into the sequence as needed to create opportunities for parallel execution. So, for example, if you are doing a summation, then identity()
ought to produce something that represents the zero for your type (but consider just calling sum()
in that case). Read more
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
[src]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
Reduces the items in the iterator into one item using op
. If the iterator is empty, None
is returned; otherwise, Some
is returned. Read more
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
OP: Fn(T, T) -> Self::Item + Sync + Send,
ID: Fn() -> T + Sync + Send,
Self::Item: Try<Ok = T>,
[src]
OP: Fn(T, T) -> Self::Item + Sync + Send,
ID: Fn() -> T + Sync + Send,
Self::Item: Try<Ok = T>,
Reduces the items in the iterator into one item using a fallible op
. The identity
argument is used the same way as in [reduce()
]. Read more
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>,
Reduces the items in the iterator into one item using a fallible op
. Read more
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
F: Fn(T, Self::Item) -> T + Sync + Send,
ID: Fn() -> T + Sync + Send,
T: Send,
[src]
F: Fn(T, Self::Item) -> T + Sync + Send,
ID: Fn() -> T + Sync + Send,
T: Send,
Parallel fold is similar to sequential fold except that the sequence of items may be subdivided before it is folded. Consider a list of numbers like 22 3 77 89 46
. If you used sequential fold to add them (fold(0, |a,b| a+b)
, you would wind up first adding 0 + 22, then 22 + 3, then 25 + 77, and so forth. The parallel fold works similarly except that it first breaks up your list into sublists, and hence instead of yielding up a single sum at the end, it yields up multiple sums. The number of results is nondeterministic, as is the point where the breaks occur. Read more
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
F: Fn(T, Self::Item) -> T + Sync + Send,
T: Send + Clone,
[src]
F: Fn(T, Self::Item) -> T + Sync + Send,
T: Send + Clone,
Applies fold_op
to the given init
value with each item of this iterator, finally producing the value for further use. Read more
fn try_fold<T, R, ID, F>(
self,
identity: ID,
fold_op: F
) -> TryFold<Self, R, ID, F> where
F: Fn(T, Self::Item) -> R + Sync + Send,
ID: Fn() -> T + Sync + Send,
R: Try<Ok = T> + Send,
[src]
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,
Perform a fallible parallel fold. Read more
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
F: Fn(T, Self::Item) -> R + Sync + Send,
R: Try<Ok = T> + Send,
T: Clone + Send,
[src]
F: Fn(T, Self::Item) -> R + Sync + Send,
R: Try<Ok = T> + Send,
T: Clone + Send,
Perform a fallible parallel fold with a cloneable init
value. Read more
fn sum<S>(self) -> S where
S: Send + Sum<Self::Item> + Sum<S>,
[src]
S: Send + Sum<Self::Item> + Sum<S>,
Sums up the items in the iterator. Read more
fn product<P>(self) -> P where
P: Send + Product<Self::Item> + Product<P>,
[src]
P: Send + Product<Self::Item> + Product<P>,
Multiplies all the items in the iterator. Read more
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
Computes the minimum of all the items in the iterator. If the iterator is empty, None
is returned; otherwise, Some(min)
is returned. Read more
fn min_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
Computes the minimum of all the items in the iterator with respect to the given comparison function. If the iterator is empty, None
is returned; otherwise, Some(min)
is returned. Read more
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
Computes the item that yields the minimum value for the given function. If the iterator is empty, None
is returned; otherwise, Some(item)
is returned. Read more
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
Computes the maximum of all the items in the iterator. If the iterator is empty, None
is returned; otherwise, Some(max)
is returned. Read more
fn max_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
Computes the maximum of all the items in the iterator with respect to the given comparison function. If the iterator is empty, None
is returned; otherwise, Some(min)
is returned. Read more
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
Computes the item that yields the maximum value for the given function. If the iterator is empty, None
is returned; otherwise, Some(item)
is returned. Read more
fn chain<C>(self, chain: C) -> Chain<Self, C::Iter> where
C: IntoParallelIterator<Item = Self::Item>,
[src]
C: IntoParallelIterator<Item = Self::Item>,
Takes two iterators and creates a new iterator over both. Read more
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
P: Fn(&Self::Item) -> bool + Sync + Send,
Searches for some item in the parallel iterator that matches the given predicate and returns it. This operation is similar to [find
on sequential iterators][find] but the item returned may not be the first one in the parallel sequence which matches, since we search the entire sequence in parallel. Read more
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
P: Fn(&Self::Item) -> bool + Sync + Send,
Searches for the sequentially first item in the parallel iterator that matches the given predicate and returns it. Read more
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
P: Fn(&Self::Item) -> bool + Sync + Send,
Searches for the sequentially last item in the parallel iterator that matches the given predicate and returns it. Read more
fn find_map_any<P, R>(self, predicate: P) -> Option<R> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
Applies the given predicate to the items in the parallel iterator and returns any non-None result of the map operation. Read more
fn find_map_first<P, R>(self, predicate: P) -> Option<R> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
Applies the given predicate to the items in the parallel iterator and returns the sequentially first non-None result of the map operation. Read more
fn find_map_last<P, R>(self, predicate: P) -> Option<R> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
Applies the given predicate to the items in the parallel iterator and returns the sequentially last non-None result of the map operation. Read more
fn any<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
Searches for some item in the parallel iterator that matches the given predicate, and if so returns true. Once a match is found, we'll attempt to stop process the rest of the items. Proving that there's no match, returning false, does require visiting every item. Read more
fn all<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
Tests that every item in the parallel iterator matches the given predicate, and if so returns true. If a counter-example is found, we'll attempt to stop processing more items, then return false. Read more
fn while_some<T>(self) -> WhileSome<Self> where
Self: ParallelIterator<Item = Option<T>>,
T: Send,
[src]
Self: ParallelIterator<Item = Option<T>>,
T: Send,
Creates an iterator over the Some
items of this iterator, halting as soon as any None
is found. Read more
fn panic_fuse(self) -> PanicFuse<Self>
[src]
Wraps an iterator with a fuse in case of panics, to halt all threads as soon as possible. Read more
fn collect<C>(self) -> C where
C: FromParallelIterator<Self::Item>,
[src]
C: FromParallelIterator<Self::Item>,
Create a fresh collection containing all the element produced by this parallel iterator. Read more
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
Self: ParallelIterator<Item = (A, B)>,
FromA: Default + Send + ParallelExtend<A>,
FromB: Default + Send + ParallelExtend<B>,
A: Send,
B: Send,
[src]
Self: ParallelIterator<Item = (A, B)>,
FromA: Default + Send + ParallelExtend<A>,
FromB: Default + Send + ParallelExtend<B>,
A: Send,
B: Send,
Unzips the items of a parallel iterator into a pair of arbitrary ParallelExtend
containers. Read more
fn partition<A, B, P>(self, predicate: P) -> (A, B) where
A: Default + Send + ParallelExtend<Self::Item>,
B: Default + Send + ParallelExtend<Self::Item>,
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
A: Default + Send + ParallelExtend<Self::Item>,
B: Default + Send + ParallelExtend<Self::Item>,
P: Fn(&Self::Item) -> bool + Sync + Send,
Partitions the items of a parallel iterator into a pair of arbitrary ParallelExtend
containers. Items for which the predicate
returns true go into the first container, and the rest go into the second. Read more
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
A: Default + Send + ParallelExtend<L>,
B: Default + Send + ParallelExtend<R>,
P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
L: Send,
R: Send,
[src]
A: Default + Send + ParallelExtend<L>,
B: Default + Send + ParallelExtend<R>,
P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
L: Send,
R: Send,
Partitions and maps the items of a parallel iterator into a pair of arbitrary ParallelExtend
containers. Either::Left
items go into the first container, and Either::Right
items go into the second. Read more
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]
Self::Item: Clone,
Intersperses clones of an element between items of this iterator. Read more
impl<T: Clone + Send> Clone for IntoIter<T>
[src]
fn clone(&self) -> IntoIter<T>
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl<T: Debug + Send> Debug for IntoIter<T>
[src]
Auto Trait Implementations
impl<T> Unpin for IntoIter<T> where
T: Unpin,
T: Unpin,
impl<T> Sync for IntoIter<T> where
T: Sync,
T: Sync,
impl<T> Send for IntoIter<T>
impl<T> UnwindSafe for IntoIter<T> where
T: UnwindSafe,
T: UnwindSafe,
impl<T> RefUnwindSafe for IntoIter<T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
Blanket Implementations
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> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
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>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
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> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,