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<'data, T: Sync + 'data, const N: usize> IntoParallelIterator for &'data [T; N]

This implementation requires const generics, stabilized in Rust 1.51.

type Item = &'data T

type Iter = Iter<'data, T>

fn into_par_iter(self) -> Self::Iter

impl<'data, T: Send + 'data, const N: usize> IntoParallelIterator for &'data mut [T; N]

This implementation requires const generics, stabilized in Rust 1.51.

type Item = &'data mut T

type Iter = IterMut<'data, T>

fn into_par_iter(self) -> Self::Iter

impl<T: Send, const N: usize> IntoParallelIterator for [T; N]

This implementation requires const generics, stabilized in Rust 1.51.

type Item = T

type Iter = IntoIter<T, N>

fn into_par_iter(self) -> Self::Iter

impl<T: Ord + Send> IntoParallelIterator for BinaryHeap<T>

type Item = T

type Iter = IntoIter<T>

fn into_par_iter(self) -> Self::Iter

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

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

type Iter = Iter<'a, T>

fn into_par_iter(self) -> Self::Iter

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

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

type Iter = IntoIter<K, V>

fn into_par_iter(self) -> Self::Iter

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

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

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

fn into_par_iter(self) -> Self::Iter

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

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

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

fn into_par_iter(self) -> Self::Iter

impl<T: Ord + Send> IntoParallelIterator for BTreeSet<T>

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

type Iter = IntoIter<T>

fn into_par_iter(self) -> Self::Iter

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

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

type Iter = Iter<'a, T>

fn into_par_iter(self) -> Self::Iter

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

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

type Iter = IntoIter<K, V>

fn into_par_iter(self) -> Self::Iter

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

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

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

fn into_par_iter(self) -> Self::Iter

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

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

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

fn into_par_iter(self) -> Self::Iter

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

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

type Iter = IntoIter<T>

fn into_par_iter(self) -> Self::Iter

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

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

type Iter = Iter<'a, T>

fn into_par_iter(self) -> Self::Iter

impl<T: Send> IntoParallelIterator for LinkedList<T>

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

type Iter = IntoIter<T>

fn into_par_iter(self) -> Self::Iter

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

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

type Iter = Iter<'a, T>

fn into_par_iter(self) -> Self::Iter

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

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

type Iter = IterMut<'a, T>

fn into_par_iter(self) -> Self::Iter

impl<T: Send> IntoParallelIterator for VecDeque<T>

type Item = T

type Iter = IntoIter<T>

fn into_par_iter(self) -> Self::Iter

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

type Item = &'a T

type Iter = Iter<'a, T>

fn into_par_iter(self) -> Self::Iter

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

type Item = &'a mut T

type Iter = IterMut<'a, T>

fn into_par_iter(self) -> Self::Iter

impl<A> IntoParallelIterator for (A,) where
    A: IntoParallelIterator,
    A::Iter: IndexedParallelIterator, 

type Item = (A::Item,)

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

fn into_par_iter(self) -> Self::Iter

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

type Item = (A::Item,)

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

fn into_par_iter(self) -> Self::Iter

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

type Item = (A::Item,)

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

fn into_par_iter(self) -> Self::Iter

impl<A, B> IntoParallelIterator for (A, B) where
    A: IntoParallelIterator,
    A::Iter: IndexedParallelIterator,
    B: IntoParallelIterator,
    B::Iter: IndexedParallelIterator, 

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

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

fn into_par_iter(self) -> Self::Iter

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

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

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

fn into_par_iter(self) -> Self::Iter

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

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

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

fn into_par_iter(self) -> Self::Iter

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, 

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

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

fn into_par_iter(self) -> Self::Iter

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, 

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

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

fn into_par_iter(self) -> Self::Iter

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, 

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

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

fn into_par_iter(self) -> Self::Iter

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, 

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

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, 

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

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, 

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

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, 

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

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, 

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

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, 

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

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, 

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

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, 

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

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, 

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

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, 

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

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, 

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

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, 

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

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, 

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

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, 

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

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, 

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

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, 

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

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, 

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

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, 

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

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, 

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

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, 

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

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, 

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

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, 

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

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, 

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

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, 

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

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, 

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

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, 

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

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, 

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

impl<T: Send> IntoParallelIterator for Option<T>

type Item = T

type Iter = IntoIter<T>

fn into_par_iter(self) -> Self::Iter

impl<'a, T: Sync> IntoParallelIterator for &'a Option<T>

type Item = &'a T

type Iter = Iter<'a, T>

fn into_par_iter(self) -> Self::Iter

impl<'a, T: Send> IntoParallelIterator for &'a mut Option<T>

type Item = &'a mut T

type Iter = IterMut<'a, T>

fn into_par_iter(self) -> Self::Iter

impl<T> IntoParallelIterator for Range<T> where
    Iter<T>: ParallelIterator, 

Implemented for ranges of all primitive integer types and char.

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

type Iter = Iter<T>

fn into_par_iter(self) -> Self::Iter

impl<T> IntoParallelIterator for RangeInclusive<T> where
    Iter<T>: ParallelIterator, 

Implemented for ranges of all primitive integer types and char.

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

type Iter = Iter<T>

fn into_par_iter(self) -> Self::Iter

impl<T: Send, E> IntoParallelIterator for Result<T, E>

type Item = T

type Iter = IntoIter<T>

fn into_par_iter(self) -> Self::Iter

impl<'a, T: Sync, E> IntoParallelIterator for &'a Result<T, E>

type Item = &'a T

type Iter = Iter<'a, T>

fn into_par_iter(self) -> Self::Iter

impl<'a, T: Send, E> IntoParallelIterator for &'a mut Result<T, E>

type Item = &'a mut T

type Iter = IterMut<'a, T>

fn into_par_iter(self) -> Self::Iter

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

type Item = &'data T

type Iter = Iter<'data, T>

fn into_par_iter(self) -> Self::Iter

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

type Item = &'data mut T

type Iter = IterMut<'data, T>

fn into_par_iter(self) -> Self::Iter

impl<'data, T: Sync + 'data> IntoParallelIterator for &'data Vec<T>

type Item = &'data T

type Iter = Iter<'data, T>

fn into_par_iter(self) -> Self::Iter

impl<'data, T: Send + 'data> IntoParallelIterator for &'data mut Vec<T>

type Item = &'data mut T

type Iter = IterMut<'data, T>

fn into_par_iter(self) -> Self::Iter

impl<T: Send> IntoParallelIterator for Vec<T>

type Item = T

type Iter = IntoIter<T>

fn into_par_iter(self) -> Self::Iter

Loading content...

Implementors

impl<T: ParallelIterator> IntoParallelIterator for T

type Iter = T

type Item = T::Item

fn into_par_iter(self) -> T

Loading content...