[][src]Struct rayon::collections::hash_map::IntoIter

pub struct IntoIter<K: Hash + Eq + Send, V: Send> { /* fields omitted */ }

Parallel iterator over a hash map

Trait Implementations

impl<K: Hash + Eq + Send, V: Send> ParallelIterator for IntoIter<K, V>[src]

type Item = (K, V)

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 for_each<OP>(self, op: OP) where
    OP: Fn(Self::Item) + Sync + Send
[src]

Executes OP on each item produced by the iterator, in parallel. Read more

fn for_each_with<OP, T>(self, init: T, op: OP) where
    OP: Fn(&mut T, Self::Item) + Sync + Send,
    T: Send + Clone
[src]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

An adaptor that flattens iterable Items 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]

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]

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]

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]

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]

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]

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]

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]

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]

Sums up the items in the iterator. Read more

fn product<P>(self) -> P where
    P: Send + Product<Self::Item> + Product<P>, 
[src]

Multiplies all the items in the iterator. Read more

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord
[src]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

Intersperses clones of an element between items of this iterator. Read more

impl<K: Debug + Hash + Eq + Send, V: Debug + Send> Debug for IntoIter<K, V>[src]

Auto Trait Implementations

impl<K, V> Unpin for IntoIter<K, V> where
    K: Unpin,
    V: Unpin

impl<K, V> Sync for IntoIter<K, V> where
    K: Sync,
    V: Sync

impl<K, V> Send for IntoIter<K, V>

impl<K, V> UnwindSafe for IntoIter<K, V> where
    K: UnwindSafe,
    V: UnwindSafe

impl<K, V> RefUnwindSafe for IntoIter<K, V> where
    K: RefUnwindSafe,
    V: RefUnwindSafe

Blanket Implementations

impl<T> IntoParallelIterator for T where
    T: ParallelIterator
[src]

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.

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]