[−][src]Trait rayon::iter::IntoParallelIterator

pub trait IntoParallelIterator {
    type Iter: ParallelIterator<Item = Self::Item>;
    type Item: Send;
    fn into_par_iter(self) -> Self::Iter;
}

IntoParallelIterator implements the conversion to a ParallelIterator.

By implementing IntoParallelIterator for a type, you define how it will transformed into an iterator. This is a parallel version of the standard library's std::iter::IntoIterator trait.

Associated Types

`type Iter: ParallelIterator<Item = Self::Item>`

The parallel iterator type that will be created.

`type Item: Send`

The type of item that the parallel iterator will produce.

Loading content...

Required methods

`fn into_par_iter(self) -> Self::Iter`

Converts self into a parallel iterator.

Examples

use rayon::prelude::*;

println!("counting in parallel:");
(0..100).into_par_iter()
    .for_each(|i| println!("{}", i));

This conversion is often implicit for arguments to methods like zip.

use rayon::prelude::*;

let v: Vec<_> = (0..5).into_par_iter().zip(5..10).collect();
assert_eq!(v, [(0, 5), (1, 6), (2, 7), (3, 8), (4, 9)]);

Loading content...

Implementations on Foreign Types

`impl<T: Ord + Send> IntoParallelIterator for BinaryHeap<T>`[src]

`type Item = T`

`type Iter = IntoIter<T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, T: Ord + Sync> IntoParallelIterator for &'a BinaryHeap<T>`[src]

`type Item = <&'a BinaryHeap<T> as IntoIterator>::Item`

`type Iter = Iter<'a, T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<K: Ord + Send, V: Send> IntoParallelIterator for BTreeMap<K, V>`[src]

`type Item = <BTreeMap<K, V> as IntoIterator>::Item`

`type Iter = IntoIter<K, V>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, K: Ord + Sync, V: Sync> IntoParallelIterator for &'a BTreeMap<K, V>`[src]

`type Item = <&'a BTreeMap<K, V> as IntoIterator>::Item`

`type Iter = Iter<'a, K, V>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, K: Ord + Sync, V: Send> IntoParallelIterator for &'a mut BTreeMap<K, V>`[src]

`type Item = <&'a mut BTreeMap<K, V> as IntoIterator>::Item`

`type Iter = IterMut<'a, K, V>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<T: Ord + Send> IntoParallelIterator for BTreeSet<T>`[src]

`type Item = <BTreeSet<T> as IntoIterator>::Item`

`type Iter = IntoIter<T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, T: Ord + Sync> IntoParallelIterator for &'a BTreeSet<T>`[src]

`type Item = <&'a BTreeSet<T> as IntoIterator>::Item`

`type Iter = Iter<'a, T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<K: Hash + Eq + Send, V: Send, S: BuildHasher> IntoParallelIterator for HashMap<K, V, S>`[src]

`type Item = <HashMap<K, V, S> as IntoIterator>::Item`

`type Iter = IntoIter<K, V>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, K: Hash + Eq + Sync, V: Sync, S: BuildHasher> IntoParallelIterator for &'a HashMap<K, V, S>`[src]

`type Item = <&'a HashMap<K, V, S> as IntoIterator>::Item`

`type Iter = Iter<'a, K, V>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, K: Hash + Eq + Sync, V: Send, S: BuildHasher> IntoParallelIterator for &'a mut HashMap<K, V, S>`[src]

`type Item = <&'a mut HashMap<K, V, S> as IntoIterator>::Item`

`type Iter = IterMut<'a, K, V>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<T: Hash + Eq + Send, S: BuildHasher> IntoParallelIterator for HashSet<T, S>`[src]

`type Item = <HashSet<T, S> as IntoIterator>::Item`

`type Iter = IntoIter<T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, T: Hash + Eq + Sync, S: BuildHasher> IntoParallelIterator for &'a HashSet<T, S>`[src]

`type Item = <&'a HashSet<T, S> as IntoIterator>::Item`

`type Iter = Iter<'a, T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<T: Send> IntoParallelIterator for LinkedList<T>`[src]

`type Item = <LinkedList<T> as IntoIterator>::Item`

`type Iter = IntoIter<T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, T: Sync> IntoParallelIterator for &'a LinkedList<T>`[src]

`type Item = <&'a LinkedList<T> as IntoIterator>::Item`

`type Iter = Iter<'a, T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, T: Send> IntoParallelIterator for &'a mut LinkedList<T>`[src]

`type Item = <&'a mut LinkedList<T> as IntoIterator>::Item`

`type Iter = IterMut<'a, T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<T: Send> IntoParallelIterator for VecDeque<T>`[src]

`type Item = <VecDeque<T> as IntoIterator>::Item`

`type Iter = IntoIter<T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, T: Sync> IntoParallelIterator for &'a VecDeque<T>`[src]

`type Item = &'a T`

`type Iter = Iter<'a, T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, T: Send> IntoParallelIterator for &'a mut VecDeque<T>`[src]

`type Item = &'a mut T`

`type Iter = IterMut<'a, T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<A> IntoParallelIterator for (A,) where A: IntoParallelIterator, A::Iter: IndexedParallelIterator,` [src]

`type Item = (A::Item,)`

`type Iter = MultiZip<(A::Iter,)>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, A> IntoParallelIterator for &'a (A,) where A: IntoParallelRefIterator<'a>, A::Iter: IndexedParallelIterator,` [src]

`type Item = (A::Item,)`

`type Iter = MultiZip<(A::Iter,)>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, A> IntoParallelIterator for &'a mut (A,) where A: IntoParallelRefMutIterator<'a>, A::Iter: IndexedParallelIterator,` [src]

`type Item = (A::Item,)`

`type Iter = MultiZip<(A::Iter,)>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<A, B> IntoParallelIterator for (A, B) where A: IntoParallelIterator, A::Iter: IndexedParallelIterator, B: IntoParallelIterator, B::Iter: IndexedParallelIterator,` [src]

`type Item = (A::Item, B::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, A, B> IntoParallelIterator for &'a (A, B) where A: IntoParallelRefIterator<'a>, A::Iter: IndexedParallelIterator, B: IntoParallelRefIterator<'a>, B::Iter: IndexedParallelIterator,` [src]

`type Item = (A::Item, B::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, A, B> IntoParallelIterator for &'a mut (A, B) where A: IntoParallelRefMutIterator<'a>, A::Iter: IndexedParallelIterator, B: IntoParallelRefMutIterator<'a>, B::Iter: IndexedParallelIterator,` [src]

`type Item = (A::Item, B::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<A, B, C> IntoParallelIterator for (A, B, C) where A: IntoParallelIterator, A::Iter: IndexedParallelIterator, B: IntoParallelIterator, B::Iter: IndexedParallelIterator, C: IntoParallelIterator, C::Iter: IndexedParallelIterator,` [src]

`type Item = (A::Item, B::Item, C::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, A, B, C> IntoParallelIterator for &'a (A, B, C) where A: IntoParallelRefIterator<'a>, A::Iter: IndexedParallelIterator, B: IntoParallelRefIterator<'a>, B::Iter: IndexedParallelIterator, C: IntoParallelRefIterator<'a>, C::Iter: IndexedParallelIterator,` [src]

`type Item = (A::Item, B::Item, C::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, A, B, C> IntoParallelIterator for &'a mut (A, B, C) where A: IntoParallelRefMutIterator<'a>, A::Iter: IndexedParallelIterator, B: IntoParallelRefMutIterator<'a>, B::Iter: IndexedParallelIterator, C: IntoParallelRefMutIterator<'a>, C::Iter: IndexedParallelIterator,` [src]

`type Item = (A::Item, B::Item, C::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<A, B, C, D> IntoParallelIterator for (A, B, C, D) where A: IntoParallelIterator, A::Iter: IndexedParallelIterator, B: IntoParallelIterator, B::Iter: IndexedParallelIterator, C: IntoParallelIterator, C::Iter: IndexedParallelIterator, D: IntoParallelIterator, D::Iter: IndexedParallelIterator,` [src]

`type Item = (A::Item, B::Item, C::Item, D::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, A, B, C, D> IntoParallelIterator for &'a (A, B, C, D) where A: IntoParallelRefIterator<'a>, A::Iter: IndexedParallelIterator, B: IntoParallelRefIterator<'a>, B::Iter: IndexedParallelIterator, C: IntoParallelRefIterator<'a>, C::Iter: IndexedParallelIterator, D: IntoParallelRefIterator<'a>, D::Iter: IndexedParallelIterator,` [src]

`type Item = (A::Item, B::Item, C::Item, D::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, A, B, C, D> IntoParallelIterator for &'a mut (A, B, C, D) where A: IntoParallelRefMutIterator<'a>, A::Iter: IndexedParallelIterator, B: IntoParallelRefMutIterator<'a>, B::Iter: IndexedParallelIterator, C: IntoParallelRefMutIterator<'a>, C::Iter: IndexedParallelIterator, D: IntoParallelRefMutIterator<'a>, D::Iter: IndexedParallelIterator,` [src]

`type Item = (A::Item, B::Item, C::Item, D::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<A, B, C, D, E> IntoParallelIterator for (A, B, C, D, E) where A: IntoParallelIterator, A::Iter: IndexedParallelIterator, B: IntoParallelIterator, B::Iter: IndexedParallelIterator, C: IntoParallelIterator, C::Iter: IndexedParallelIterator, D: IntoParallelIterator, D::Iter: IndexedParallelIterator, E: IntoParallelIterator, E::Iter: IndexedParallelIterator,` [src]

`type Item = (A::Item, B::Item, C::Item, D::Item, E::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter, E::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, A, B, C, D, E> IntoParallelIterator for &'a (A, B, C, D, E) where A: IntoParallelRefIterator<'a>, A::Iter: IndexedParallelIterator, B: IntoParallelRefIterator<'a>, B::Iter: IndexedParallelIterator, C: IntoParallelRefIterator<'a>, C::Iter: IndexedParallelIterator, D: IntoParallelRefIterator<'a>, D::Iter: IndexedParallelIterator, E: IntoParallelRefIterator<'a>, E::Iter: IndexedParallelIterator,` [src]

`type Item = (A::Item, B::Item, C::Item, D::Item, E::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter, E::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

impl<'a, A, B, C, D, E> IntoParallelIterator for &'a mut (A, B, C, D, E) where A: IntoParallelRefMutIterator<'a>, A::Iter: IndexedParallelIterator, B: IntoParallelRefMutIterator<'a>, B::Iter: IndexedParallelIterator, C: IntoParallelRefMutIterator<'a>, C::Iter: IndexedParallelIterator, D: IntoParallelRefMutIterator<'a>, D::Iter: IndexedParallelIterator, E: IntoParallelRefMutIterator<'a>, E::Iter: IndexedParallelIterator, [src]

`type Item = (A::Item, B::Item, C::Item, D::Item, E::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter, E::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

impl<A, B, C, D, E, F> IntoParallelIterator for (A, B, C, D, E, F) where A: IntoParallelIterator, A::Iter: IndexedParallelIterator, B: IntoParallelIterator, B::Iter: IndexedParallelIterator, C: IntoParallelIterator, C::Iter: IndexedParallelIterator, D: IntoParallelIterator, D::Iter: IndexedParallelIterator, E: IntoParallelIterator, E::Iter: IndexedParallelIterator, F: IntoParallelIterator, F::Iter: IndexedParallelIterator, [src]

`type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter, E::Iter, F::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

impl<'a, A, B, C, D, E, F> IntoParallelIterator for &'a (A, B, C, D, E, F) where A: IntoParallelRefIterator<'a>, A::Iter: IndexedParallelIterator, B: IntoParallelRefIterator<'a>, B::Iter: IndexedParallelIterator, C: IntoParallelRefIterator<'a>, C::Iter: IndexedParallelIterator, D: IntoParallelRefIterator<'a>, D::Iter: IndexedParallelIterator, E: IntoParallelRefIterator<'a>, E::Iter: IndexedParallelIterator, F: IntoParallelRefIterator<'a>, F::Iter: IndexedParallelIterator, [src]

`type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter, E::Iter, F::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

impl<'a, A, B, C, D, E, F> IntoParallelIterator for &'a mut (A, B, C, D, E, F) where A: IntoParallelRefMutIterator<'a>, A::Iter: IndexedParallelIterator, B: IntoParallelRefMutIterator<'a>, B::Iter: IndexedParallelIterator, C: IntoParallelRefMutIterator<'a>, C::Iter: IndexedParallelIterator, D: IntoParallelRefMutIterator<'a>, D::Iter: IndexedParallelIterator, E: IntoParallelRefMutIterator<'a>, E::Iter: IndexedParallelIterator, F: IntoParallelRefMutIterator<'a>, F::Iter: IndexedParallelIterator, [src]

`type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter, E::Iter, F::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

impl<A, B, C, D, E, F, G> IntoParallelIterator for (A, B, C, D, E, F, G) where A: IntoParallelIterator, A::Iter: IndexedParallelIterator, B: IntoParallelIterator, B::Iter: IndexedParallelIterator, C: IntoParallelIterator, C::Iter: IndexedParallelIterator, D: IntoParallelIterator, D::Iter: IndexedParallelIterator, E: IntoParallelIterator, E::Iter: IndexedParallelIterator, F: IntoParallelIterator, F::Iter: IndexedParallelIterator, G: IntoParallelIterator, G::Iter: IndexedParallelIterator, [src]

`type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter, E::Iter, F::Iter, G::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

impl<'a, A, B, C, D, E, F, G> IntoParallelIterator for &'a (A, B, C, D, E, F, G) where A: IntoParallelRefIterator<'a>, A::Iter: IndexedParallelIterator, B: IntoParallelRefIterator<'a>, B::Iter: IndexedParallelIterator, C: IntoParallelRefIterator<'a>, C::Iter: IndexedParallelIterator, D: IntoParallelRefIterator<'a>, D::Iter: IndexedParallelIterator, E: IntoParallelRefIterator<'a>, E::Iter: IndexedParallelIterator, F: IntoParallelRefIterator<'a>, F::Iter: IndexedParallelIterator, G: IntoParallelRefIterator<'a>, G::Iter: IndexedParallelIterator, [src]

`type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter, E::Iter, F::Iter, G::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

impl<'a, A, B, C, D, E, F, G> IntoParallelIterator for &'a mut (A, B, C, D, E, F, G) where A: IntoParallelRefMutIterator<'a>, A::Iter: IndexedParallelIterator, B: IntoParallelRefMutIterator<'a>, B::Iter: IndexedParallelIterator, C: IntoParallelRefMutIterator<'a>, C::Iter: IndexedParallelIterator, D: IntoParallelRefMutIterator<'a>, D::Iter: IndexedParallelIterator, E: IntoParallelRefMutIterator<'a>, E::Iter: IndexedParallelIterator, F: IntoParallelRefMutIterator<'a>, F::Iter: IndexedParallelIterator, G: IntoParallelRefMutIterator<'a>, G::Iter: IndexedParallelIterator, [src]

`type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter, E::Iter, F::Iter, G::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

impl<A, B, C, D, E, F, G, H> IntoParallelIterator for (A, B, C, D, E, F, G, H) where A: IntoParallelIterator, A::Iter: IndexedParallelIterator, B: IntoParallelIterator, B::Iter: IndexedParallelIterator, C: IntoParallelIterator, C::Iter: IndexedParallelIterator, D: IntoParallelIterator, D::Iter: IndexedParallelIterator, E: IntoParallelIterator, E::Iter: IndexedParallelIterator, F: IntoParallelIterator, F::Iter: IndexedParallelIterator, G: IntoParallelIterator, G::Iter: IndexedParallelIterator, H: IntoParallelIterator, H::Iter: IndexedParallelIterator, [src]

`type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter, E::Iter, F::Iter, G::Iter, H::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

impl<'a, A, B, C, D, E, F, G, H> IntoParallelIterator for &'a (A, B, C, D, E, F, G, H) where A: IntoParallelRefIterator<'a>, A::Iter: IndexedParallelIterator, B: IntoParallelRefIterator<'a>, B::Iter: IndexedParallelIterator, C: IntoParallelRefIterator<'a>, C::Iter: IndexedParallelIterator, D: IntoParallelRefIterator<'a>, D::Iter: IndexedParallelIterator, E: IntoParallelRefIterator<'a>, E::Iter: IndexedParallelIterator, F: IntoParallelRefIterator<'a>, F::Iter: IndexedParallelIterator, G: IntoParallelRefIterator<'a>, G::Iter: IndexedParallelIterator, H: IntoParallelRefIterator<'a>, H::Iter: IndexedParallelIterator, [src]

`type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter, E::Iter, F::Iter, G::Iter, H::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

impl<'a, A, B, C, D, E, F, G, H> IntoParallelIterator for &'a mut (A, B, C, D, E, F, G, H) where A: IntoParallelRefMutIterator<'a>, A::Iter: IndexedParallelIterator, B: IntoParallelRefMutIterator<'a>, B::Iter: IndexedParallelIterator, C: IntoParallelRefMutIterator<'a>, C::Iter: IndexedParallelIterator, D: IntoParallelRefMutIterator<'a>, D::Iter: IndexedParallelIterator, E: IntoParallelRefMutIterator<'a>, E::Iter: IndexedParallelIterator, F: IntoParallelRefMutIterator<'a>, F::Iter: IndexedParallelIterator, G: IntoParallelRefMutIterator<'a>, G::Iter: IndexedParallelIterator, H: IntoParallelRefMutIterator<'a>, H::Iter: IndexedParallelIterator, [src]

`type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter, E::Iter, F::Iter, G::Iter, H::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

impl<A, B, C, D, E, F, G, H, I> IntoParallelIterator for (A, B, C, D, E, F, G, H, I) where A: IntoParallelIterator, A::Iter: IndexedParallelIterator, B: IntoParallelIterator, B::Iter: IndexedParallelIterator, C: IntoParallelIterator, C::Iter: IndexedParallelIterator, D: IntoParallelIterator, D::Iter: IndexedParallelIterator, E: IntoParallelIterator, E::Iter: IndexedParallelIterator, F: IntoParallelIterator, F::Iter: IndexedParallelIterator, G: IntoParallelIterator, G::Iter: IndexedParallelIterator, H: IntoParallelIterator, H::Iter: IndexedParallelIterator, I: IntoParallelIterator, I::Iter: IndexedParallelIterator, [src]

`type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter, E::Iter, F::Iter, G::Iter, H::Iter, I::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

impl<'a, A, B, C, D, E, F, G, H, I> IntoParallelIterator for &'a (A, B, C, D, E, F, G, H, I) where A: IntoParallelRefIterator<'a>, A::Iter: IndexedParallelIterator, B: IntoParallelRefIterator<'a>, B::Iter: IndexedParallelIterator, C: IntoParallelRefIterator<'a>, C::Iter: IndexedParallelIterator, D: IntoParallelRefIterator<'a>, D::Iter: IndexedParallelIterator, E: IntoParallelRefIterator<'a>, E::Iter: IndexedParallelIterator, F: IntoParallelRefIterator<'a>, F::Iter: IndexedParallelIterator, G: IntoParallelRefIterator<'a>, G::Iter: IndexedParallelIterator, H: IntoParallelRefIterator<'a>, H::Iter: IndexedParallelIterator, I: IntoParallelRefIterator<'a>, I::Iter: IndexedParallelIterator, [src]

`type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter, E::Iter, F::Iter, G::Iter, H::Iter, I::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

impl<'a, A, B, C, D, E, F, G, H, I> IntoParallelIterator for &'a mut (A, B, C, D, E, F, G, H, I) where A: IntoParallelRefMutIterator<'a>, A::Iter: IndexedParallelIterator, B: IntoParallelRefMutIterator<'a>, B::Iter: IndexedParallelIterator, C: IntoParallelRefMutIterator<'a>, C::Iter: IndexedParallelIterator, D: IntoParallelRefMutIterator<'a>, D::Iter: IndexedParallelIterator, E: IntoParallelRefMutIterator<'a>, E::Iter: IndexedParallelIterator, F: IntoParallelRefMutIterator<'a>, F::Iter: IndexedParallelIterator, G: IntoParallelRefMutIterator<'a>, G::Iter: IndexedParallelIterator, H: IntoParallelRefMutIterator<'a>, H::Iter: IndexedParallelIterator, I: IntoParallelRefMutIterator<'a>, I::Iter: IndexedParallelIterator, [src]

`type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter, E::Iter, F::Iter, G::Iter, H::Iter, I::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

impl<A, B, C, D, E, F, G, H, I, J> IntoParallelIterator for (A, B, C, D, E, F, G, H, I, J) where A: IntoParallelIterator, A::Iter: IndexedParallelIterator, B: IntoParallelIterator, B::Iter: IndexedParallelIterator, C: IntoParallelIterator, C::Iter: IndexedParallelIterator, D: IntoParallelIterator, D::Iter: IndexedParallelIterator, E: IntoParallelIterator, E::Iter: IndexedParallelIterator, F: IntoParallelIterator, F::Iter: IndexedParallelIterator, G: IntoParallelIterator, G::Iter: IndexedParallelIterator, H: IntoParallelIterator, H::Iter: IndexedParallelIterator, I: IntoParallelIterator, I::Iter: IndexedParallelIterator, J: IntoParallelIterator, J::Iter: IndexedParallelIterator, [src]

`type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item, J::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter, E::Iter, F::Iter, G::Iter, H::Iter, I::Iter, J::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

impl<'a, A, B, C, D, E, F, G, H, I, J> IntoParallelIterator for &'a (A, B, C, D, E, F, G, H, I, J) where A: IntoParallelRefIterator<'a>, A::Iter: IndexedParallelIterator, B: IntoParallelRefIterator<'a>, B::Iter: IndexedParallelIterator, C: IntoParallelRefIterator<'a>, C::Iter: IndexedParallelIterator, D: IntoParallelRefIterator<'a>, D::Iter: IndexedParallelIterator, E: IntoParallelRefIterator<'a>, E::Iter: IndexedParallelIterator, F: IntoParallelRefIterator<'a>, F::Iter: IndexedParallelIterator, G: IntoParallelRefIterator<'a>, G::Iter: IndexedParallelIterator, H: IntoParallelRefIterator<'a>, H::Iter: IndexedParallelIterator, I: IntoParallelRefIterator<'a>, I::Iter: IndexedParallelIterator, J: IntoParallelRefIterator<'a>, J::Iter: IndexedParallelIterator, [src]

`type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item, J::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter, E::Iter, F::Iter, G::Iter, H::Iter, I::Iter, J::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

impl<'a, A, B, C, D, E, F, G, H, I, J> IntoParallelIterator for &'a mut (A, B, C, D, E, F, G, H, I, J) where A: IntoParallelRefMutIterator<'a>, A::Iter: IndexedParallelIterator, B: IntoParallelRefMutIterator<'a>, B::Iter: IndexedParallelIterator, C: IntoParallelRefMutIterator<'a>, C::Iter: IndexedParallelIterator, D: IntoParallelRefMutIterator<'a>, D::Iter: IndexedParallelIterator, E: IntoParallelRefMutIterator<'a>, E::Iter: IndexedParallelIterator, F: IntoParallelRefMutIterator<'a>, F::Iter: IndexedParallelIterator, G: IntoParallelRefMutIterator<'a>, G::Iter: IndexedParallelIterator, H: IntoParallelRefMutIterator<'a>, H::Iter: IndexedParallelIterator, I: IntoParallelRefMutIterator<'a>, I::Iter: IndexedParallelIterator, J: IntoParallelRefMutIterator<'a>, J::Iter: IndexedParallelIterator, [src]

`type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item, J::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter, E::Iter, F::Iter, G::Iter, H::Iter, I::Iter, J::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

impl<A, B, C, D, E, F, G, H, I, J, K> IntoParallelIterator for (A, B, C, D, E, F, G, H, I, J, K) where A: IntoParallelIterator, A::Iter: IndexedParallelIterator, B: IntoParallelIterator, B::Iter: IndexedParallelIterator, C: IntoParallelIterator, C::Iter: IndexedParallelIterator, D: IntoParallelIterator, D::Iter: IndexedParallelIterator, E: IntoParallelIterator, E::Iter: IndexedParallelIterator, F: IntoParallelIterator, F::Iter: IndexedParallelIterator, G: IntoParallelIterator, G::Iter: IndexedParallelIterator, H: IntoParallelIterator, H::Iter: IndexedParallelIterator, I: IntoParallelIterator, I::Iter: IndexedParallelIterator, J: IntoParallelIterator, J::Iter: IndexedParallelIterator, K: IntoParallelIterator, K::Iter: IndexedParallelIterator, [src]

`type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item, J::Item, K::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter, E::Iter, F::Iter, G::Iter, H::Iter, I::Iter, J::Iter, K::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

impl<'a, A, B, C, D, E, F, G, H, I, J, K> IntoParallelIterator for &'a (A, B, C, D, E, F, G, H, I, J, K) where A: IntoParallelRefIterator<'a>, A::Iter: IndexedParallelIterator, B: IntoParallelRefIterator<'a>, B::Iter: IndexedParallelIterator, C: IntoParallelRefIterator<'a>, C::Iter: IndexedParallelIterator, D: IntoParallelRefIterator<'a>, D::Iter: IndexedParallelIterator, E: IntoParallelRefIterator<'a>, E::Iter: IndexedParallelIterator, F: IntoParallelRefIterator<'a>, F::Iter: IndexedParallelIterator, G: IntoParallelRefIterator<'a>, G::Iter: IndexedParallelIterator, H: IntoParallelRefIterator<'a>, H::Iter: IndexedParallelIterator, I: IntoParallelRefIterator<'a>, I::Iter: IndexedParallelIterator, J: IntoParallelRefIterator<'a>, J::Iter: IndexedParallelIterator, K: IntoParallelRefIterator<'a>, K::Iter: IndexedParallelIterator, [src]

`type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item, J::Item, K::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter, E::Iter, F::Iter, G::Iter, H::Iter, I::Iter, J::Iter, K::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

impl<'a, A, B, C, D, E, F, G, H, I, J, K> IntoParallelIterator for &'a mut (A, B, C, D, E, F, G, H, I, J, K) where A: IntoParallelRefMutIterator<'a>, A::Iter: IndexedParallelIterator, B: IntoParallelRefMutIterator<'a>, B::Iter: IndexedParallelIterator, C: IntoParallelRefMutIterator<'a>, C::Iter: IndexedParallelIterator, D: IntoParallelRefMutIterator<'a>, D::Iter: IndexedParallelIterator, E: IntoParallelRefMutIterator<'a>, E::Iter: IndexedParallelIterator, F: IntoParallelRefMutIterator<'a>, F::Iter: IndexedParallelIterator, G: IntoParallelRefMutIterator<'a>, G::Iter: IndexedParallelIterator, H: IntoParallelRefMutIterator<'a>, H::Iter: IndexedParallelIterator, I: IntoParallelRefMutIterator<'a>, I::Iter: IndexedParallelIterator, J: IntoParallelRefMutIterator<'a>, J::Iter: IndexedParallelIterator, K: IntoParallelRefMutIterator<'a>, K::Iter: IndexedParallelIterator, [src]

`type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item, J::Item, K::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter, E::Iter, F::Iter, G::Iter, H::Iter, I::Iter, J::Iter, K::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L> IntoParallelIterator for (A, B, C, D, E, F, G, H, I, J, K, L) where A: IntoParallelIterator, A::Iter: IndexedParallelIterator, B: IntoParallelIterator, B::Iter: IndexedParallelIterator, C: IntoParallelIterator, C::Iter: IndexedParallelIterator, D: IntoParallelIterator, D::Iter: IndexedParallelIterator, E: IntoParallelIterator, E::Iter: IndexedParallelIterator, F: IntoParallelIterator, F::Iter: IndexedParallelIterator, G: IntoParallelIterator, G::Iter: IndexedParallelIterator, H: IntoParallelIterator, H::Iter: IndexedParallelIterator, I: IntoParallelIterator, I::Iter: IndexedParallelIterator, J: IntoParallelIterator, J::Iter: IndexedParallelIterator, K: IntoParallelIterator, K::Iter: IndexedParallelIterator, L: IntoParallelIterator, L::Iter: IndexedParallelIterator, [src]

`type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item, J::Item, K::Item, L::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter, E::Iter, F::Iter, G::Iter, H::Iter, I::Iter, J::Iter, K::Iter, L::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L> IntoParallelIterator for &'a (A, B, C, D, E, F, G, H, I, J, K, L) where A: IntoParallelRefIterator<'a>, A::Iter: IndexedParallelIterator, B: IntoParallelRefIterator<'a>, B::Iter: IndexedParallelIterator, C: IntoParallelRefIterator<'a>, C::Iter: IndexedParallelIterator, D: IntoParallelRefIterator<'a>, D::Iter: IndexedParallelIterator, E: IntoParallelRefIterator<'a>, E::Iter: IndexedParallelIterator, F: IntoParallelRefIterator<'a>, F::Iter: IndexedParallelIterator, G: IntoParallelRefIterator<'a>, G::Iter: IndexedParallelIterator, H: IntoParallelRefIterator<'a>, H::Iter: IndexedParallelIterator, I: IntoParallelRefIterator<'a>, I::Iter: IndexedParallelIterator, J: IntoParallelRefIterator<'a>, J::Iter: IndexedParallelIterator, K: IntoParallelRefIterator<'a>, K::Iter: IndexedParallelIterator, L: IntoParallelRefIterator<'a>, L::Iter: IndexedParallelIterator, [src]

`type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item, J::Item, K::Item, L::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter, E::Iter, F::Iter, G::Iter, H::Iter, I::Iter, J::Iter, K::Iter, L::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L> IntoParallelIterator for &'a mut (A, B, C, D, E, F, G, H, I, J, K, L) where A: IntoParallelRefMutIterator<'a>, A::Iter: IndexedParallelIterator, B: IntoParallelRefMutIterator<'a>, B::Iter: IndexedParallelIterator, C: IntoParallelRefMutIterator<'a>, C::Iter: IndexedParallelIterator, D: IntoParallelRefMutIterator<'a>, D::Iter: IndexedParallelIterator, E: IntoParallelRefMutIterator<'a>, E::Iter: IndexedParallelIterator, F: IntoParallelRefMutIterator<'a>, F::Iter: IndexedParallelIterator, G: IntoParallelRefMutIterator<'a>, G::Iter: IndexedParallelIterator, H: IntoParallelRefMutIterator<'a>, H::Iter: IndexedParallelIterator, I: IntoParallelRefMutIterator<'a>, I::Iter: IndexedParallelIterator, J: IntoParallelRefMutIterator<'a>, J::Iter: IndexedParallelIterator, K: IntoParallelRefMutIterator<'a>, K::Iter: IndexedParallelIterator, L: IntoParallelRefMutIterator<'a>, L::Iter: IndexedParallelIterator, [src]

`type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item, J::Item, K::Item, L::Item)`

`type Iter = MultiZip<(A::Iter, B::Iter, C::Iter, D::Iter, E::Iter, F::Iter, G::Iter, H::Iter, I::Iter, J::Iter, K::Iter, L::Iter)>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<T: Send> IntoParallelIterator for Option<T>`[src]

`type Item = T`

`type Iter = IntoIter<T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, T: Sync> IntoParallelIterator for &'a Option<T>`[src]

`type Item = &'a T`

`type Iter = Iter<'a, T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, T: Send> IntoParallelIterator for &'a mut Option<T>`[src]

`type Item = &'a mut T`

`type Iter = IterMut<'a, T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<T> IntoParallelIterator for Range<T> where Iter<T>: ParallelIterator,` [src]

`type Item = <Iter<T> as ParallelIterator>::Item`

`type Iter = Iter<T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<T> IntoParallelIterator for RangeInclusive<T> where Iter<T>: ParallelIterator,` [src]

`type Item = <Iter<T> as ParallelIterator>::Item`

`type Iter = Iter<T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<T: Send, E> IntoParallelIterator for Result<T, E>`[src]

`type Item = T`

`type Iter = IntoIter<T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, T: Sync, E> IntoParallelIterator for &'a Result<T, E>`[src]

`type Item = &'a T`

`type Iter = Iter<'a, T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, T: Send, E> IntoParallelIterator for &'a mut Result<T, E>`[src]

`type Item = &'a mut T`

`type Iter = IterMut<'a, T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'data, T: Sync + 'data> IntoParallelIterator for &'data [T]`[src]

`type Item = &'data T`

`type Iter = Iter<'data, T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'data, T: Sync + 'data> IntoParallelIterator for &'data Vec<T>`[src]

`type Item = &'data T`

`type Iter = Iter<'data, T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'data, T: Send + 'data> IntoParallelIterator for &'data mut [T]`[src]

`type Item = &'data mut T`

`type Iter = IterMut<'data, T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'data, T: Send + 'data> IntoParallelIterator for &'data mut Vec<T>`[src]

`type Item = &'data mut T`

`type Iter = IterMut<'data, T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<T: Send> IntoParallelIterator for Vec<T>`[src]

`type Item = T`

`type Iter = IntoIter<T>`

`fn into_par_iter(self) -> Self::Iter`[src]

Loading content...

Implementors

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

`type Iter = T`

`type Item = T::Item`

`fn into_par_iter(self) -> T`[src]

Loading content...

[−][src]Trait rayon::iter::IntoParallelIterator

Associated Types

type Iter: ParallelIterator<Item = Self::Item>

type Item: Send

Required methods

fn into_par_iter(self) -> Self::Iter

Examples

Implementations on Foreign Types

impl<T: Ord + Send> IntoParallelIterator for BinaryHeap<T>[src]

type Item = T

type Iter = IntoIter<T>

fn into_par_iter(self) -> Self::Iter[src]

impl<'a, T: Ord + Sync> IntoParallelIterator for &'a BinaryHeap<T>[src]

type Item = <&'a BinaryHeap<T> as IntoIterator>::Item

type Iter = Iter<'a, T>

fn into_par_iter(self) -> Self::Iter[src]

impl<K: Ord + Send, V: Send> IntoParallelIterator for BTreeMap<K, V>[src]

type Item = <BTreeMap<K, V> as IntoIterator>::Item

type Iter = IntoIter<K, V>

fn into_par_iter(self) -> Self::Iter[src]

impl<'a, K: Ord + Sync, V: Sync> IntoParallelIterator for &'a BTreeMap<K, V>[src]

type Item = <&'a BTreeMap<K, V> as IntoIterator>::Item

type Iter = Iter<'a, K, V>

fn into_par_iter(self) -> Self::Iter[src]

impl<'a, K: Ord + Sync, V: Send> IntoParallelIterator for &'a mut BTreeMap<K, V>[src]

type Item = <&'a mut BTreeMap<K, V> as IntoIterator>::Item

type Iter = IterMut<'a, K, V>

fn into_par_iter(self) -> Self::Iter[src]

impl<T: Ord + Send> IntoParallelIterator for BTreeSet<T>[src]

type Item = <BTreeSet<T> as IntoIterator>::Item

type Iter = IntoIter<T>

fn into_par_iter(self) -> Self::Iter[src]

impl<'a, T: Ord + Sync> IntoParallelIterator for &'a BTreeSet<T>[src]

type Item = <&'a BTreeSet<T> as IntoIterator>::Item

type Iter = Iter<'a, T>

fn into_par_iter(self) -> Self::Iter[src]

impl<K: Hash + Eq + Send, V: Send, S: BuildHasher> IntoParallelIterator for HashMap<K, V, S>[src]

type Item = <HashMap<K, V, S> as IntoIterator>::Item

type Iter = IntoIter<K, V>

fn into_par_iter(self) -> Self::Iter[src]

impl<'a, K: Hash + Eq + Sync, V: Sync, S: BuildHasher> IntoParallelIterator for &'a HashMap<K, V, S>[src]

type Item = <&'a HashMap<K, V, S> as IntoIterator>::Item

type Iter = Iter<'a, K, V>

fn into_par_iter(self) -> Self::Iter[src]

impl<'a, K: Hash + Eq + Sync, V: Send, S: BuildHasher> IntoParallelIterator for &'a mut HashMap<K, V, S>[src]

type Item = <&'a mut HashMap<K, V, S> as IntoIterator>::Item

type Iter = IterMut<'a, K, V>

fn into_par_iter(self) -> Self::Iter[src]

impl<T: Hash + Eq + Send, S: BuildHasher> IntoParallelIterator for HashSet<T, S>[src]

type Item = <HashSet<T, S> as IntoIterator>::Item

type Iter = IntoIter<T>

fn into_par_iter(self) -> Self::Iter[src]

impl<'a, T: Hash + Eq + Sync, S: BuildHasher> IntoParallelIterator for &'a HashSet<T, S>[src]

type Item = <&'a HashSet<T, S> as IntoIterator>::Item

type Iter = Iter<'a, T>

fn into_par_iter(self) -> Self::Iter[src]

impl<T: Send> IntoParallelIterator for LinkedList<T>[src]

type Item = <LinkedList<T> as IntoIterator>::Item

type Iter = IntoIter<T>

fn into_par_iter(self) -> Self::Iter[src]

impl<'a, T: Sync> IntoParallelIterator for &'a LinkedList<T>[src]

type Item = <&'a LinkedList<T> as IntoIterator>::Item

type Iter = Iter<'a, T>

fn into_par_iter(self) -> Self::Iter[src]

impl<'a, T: Send> IntoParallelIterator for &'a mut LinkedList<T>[src]

type Item = <&'a mut LinkedList<T> as IntoIterator>::Item

type Iter = IterMut<'a, T>

fn into_par_iter(self) -> Self::Iter[src]

impl<T: Send> IntoParallelIterator for VecDeque<T>[src]

type Item = <VecDeque<T> as IntoIterator>::Item

type Iter = IntoIter<T>

fn into_par_iter(self) -> Self::Iter[src]

impl<'a, T: Sync> IntoParallelIterator for &'a VecDeque<T>[src]

type Item = &'a T

type Iter = Iter<'a, T>

fn into_par_iter(self) -> Self::Iter[src]

impl<'a, T: Send> IntoParallelIterator for &'a mut VecDeque<T>[src]

type Item = &'a mut T

type Iter = IterMut<'a, T>

fn into_par_iter(self) -> Self::Iter[src]

`type Iter: ParallelIterator<Item = Self::Item>`

`type Item: Send`

`fn into_par_iter(self) -> Self::Iter`

`impl<T: Ord + Send> IntoParallelIterator for BinaryHeap<T>`[src]

`type Item = T`

`type Iter = IntoIter<T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, T: Ord + Sync> IntoParallelIterator for &'a BinaryHeap<T>`[src]

`type Item = <&'a BinaryHeap<T> as IntoIterator>::Item`

`type Iter = Iter<'a, T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<K: Ord + Send, V: Send> IntoParallelIterator for BTreeMap<K, V>`[src]

`type Item = <BTreeMap<K, V> as IntoIterator>::Item`

`type Iter = IntoIter<K, V>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, K: Ord + Sync, V: Sync> IntoParallelIterator for &'a BTreeMap<K, V>`[src]

`type Item = <&'a BTreeMap<K, V> as IntoIterator>::Item`

`type Iter = Iter<'a, K, V>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, K: Ord + Sync, V: Send> IntoParallelIterator for &'a mut BTreeMap<K, V>`[src]

`type Item = <&'a mut BTreeMap<K, V> as IntoIterator>::Item`

`type Iter = IterMut<'a, K, V>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<T: Ord + Send> IntoParallelIterator for BTreeSet<T>`[src]

`type Item = <BTreeSet<T> as IntoIterator>::Item`

`type Iter = IntoIter<T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, T: Ord + Sync> IntoParallelIterator for &'a BTreeSet<T>`[src]

`type Item = <&'a BTreeSet<T> as IntoIterator>::Item`

`type Iter = Iter<'a, T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<K: Hash + Eq + Send, V: Send, S: BuildHasher> IntoParallelIterator for HashMap<K, V, S>`[src]

`type Item = <HashMap<K, V, S> as IntoIterator>::Item`

`type Iter = IntoIter<K, V>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, K: Hash + Eq + Sync, V: Sync, S: BuildHasher> IntoParallelIterator for &'a HashMap<K, V, S>`[src]

`type Item = <&'a HashMap<K, V, S> as IntoIterator>::Item`

`type Iter = Iter<'a, K, V>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, K: Hash + Eq + Sync, V: Send, S: BuildHasher> IntoParallelIterator for &'a mut HashMap<K, V, S>`[src]

`type Item = <&'a mut HashMap<K, V, S> as IntoIterator>::Item`

`type Iter = IterMut<'a, K, V>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<T: Hash + Eq + Send, S: BuildHasher> IntoParallelIterator for HashSet<T, S>`[src]

`type Item = <HashSet<T, S> as IntoIterator>::Item`

`type Iter = IntoIter<T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, T: Hash + Eq + Sync, S: BuildHasher> IntoParallelIterator for &'a HashSet<T, S>`[src]

`type Item = <&'a HashSet<T, S> as IntoIterator>::Item`

`type Iter = Iter<'a, T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<T: Send> IntoParallelIterator for LinkedList<T>`[src]

`type Item = <LinkedList<T> as IntoIterator>::Item`

`type Iter = IntoIter<T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, T: Sync> IntoParallelIterator for &'a LinkedList<T>`[src]

`type Item = <&'a LinkedList<T> as IntoIterator>::Item`

`type Iter = Iter<'a, T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, T: Send> IntoParallelIterator for &'a mut LinkedList<T>`[src]

`type Item = <&'a mut LinkedList<T> as IntoIterator>::Item`

`type Iter = IterMut<'a, T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<T: Send> IntoParallelIterator for VecDeque<T>`[src]

`type Item = <VecDeque<T> as IntoIterator>::Item`

`type Iter = IntoIter<T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, T: Sync> IntoParallelIterator for &'a VecDeque<T>`[src]

`type Item = &'a T`

`type Iter = Iter<'a, T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, T: Send> IntoParallelIterator for &'a mut VecDeque<T>`[src]

`type Item = &'a mut T`

`type Iter = IterMut<'a, T>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<A> IntoParallelIterator for (A,) where A: IntoParallelIterator, A::Iter: IndexedParallelIterator,` [src]

`type Item = (A::Item,)`

`type Iter = MultiZip<(A::Iter,)>`

`fn into_par_iter(self) -> Self::Iter`[src]

`impl<'a, A> IntoParallelIterator for &'a (A,) where A: IntoParallelRefIterator<'a>, A::Iter: IndexedParallelIterator,` [src]