Trait maybe_rayon::prelude::IntoParallelIterator

source ·

pub trait IntoParallelIterator {
    type Iter: ParallelIterator<Item = Self::Item>;
    type Item: Send;

    fn into_par_iter(self) -> Self::Iter;
}

Expand description

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.

Required Associated Types§

source

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

The parallel iterator type that will be created.

source

type Item: Send

The type of item that the parallel iterator will produce.

Required Methods§

source

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)]);

fn into_par_iter(self) -> <&'a mut (A, B) as IntoParallelIterator>::Iter

Implementors§

source §

impl<T> IntoParallelIterator for Twhere
T: ParallelIterator,

§

type Iter = T

§

Trait maybe_rayon::prelude::IntoParallelIterator

Required 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> IntoParallelIterator for BTreeSet<T, Global>where T: Ord + Send,

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

type Iter = IntoIter<T>

fn into_par_iter(self) -> <BTreeSet<T, Global> as IntoParallelIterator>::Iter

fn into_par_iter( self) -> <&'a mut (A, B, C, D, E, F, G, H, I, J, K) as IntoParallelIterator>::Iter

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

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

type Iter = IterMut<'a, T>

fn into_par_iter(self) -> <&'a mut LinkedList<T> as IntoParallelIterator>::Iter

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

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

type Iter = Iter<'a, T>

fn into_par_iter( self) -> <&'a BTreeSet<T, Global> as IntoParallelIterator>::Iter

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

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

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

fn into_par_iter(self) -> <&'a HashMap<K, V, S> as IntoParallelIterator>::Iter

type Item = (<A as IntoParallelRefMutIterator<'a>>::Item, <B as IntoParallelRefMutIterator<'a>>::Item, <C as IntoParallelRefMutIterator<'a>>::Item, <D as IntoParallelRefMutIterator<'a>>::Item)

type Iter = MultiZip<(<A as IntoParallelRefMutIterator<'a>>::Iter, <B as IntoParallelRefMutIterator<'a>>::Iter, <C as IntoParallelRefMutIterator<'a>>::Iter, <D as IntoParallelRefMutIterator<'a>>::Iter)>

fn into_par_iter(self) -> <&'a mut (A, B, C, D) as IntoParallelIterator>::Iter

type Item = (<A as IntoParallelIterator>::Item, <B as IntoParallelIterator>::Item, <C as IntoParallelIterator>::Item, <D as IntoParallelIterator>::Item, <E as IntoParallelIterator>::Item, <F as IntoParallelIterator>::Item, <G as IntoParallelIterator>::Item)

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

fn into_par_iter(self) -> <(A, B, C, D, E, F, G) as IntoParallelIterator>::Iter

fn into_par_iter( self) -> <&'a (A, B, C, D, E, F, G, H, I) as IntoParallelIterator>::Iter

type Item = (<A as IntoParallelIterator>::Item, <B as IntoParallelIterator>::Item, <C as IntoParallelIterator>::Item, <D as IntoParallelIterator>::Item, <E as IntoParallelIterator>::Item, <F as IntoParallelIterator>::Item, <G as IntoParallelIterator>::Item, <H as IntoParallelIterator>::Item)

fn into_par_iter( self) -> <(A, B, C, D, E, F, G, H) as IntoParallelIterator>::Iter

fn into_par_iter( self) -> <&'a mut (A, B, C, D, E, F, G, H, I, J) as IntoParallelIterator>::Iter

fn into_par_iter( self) -> <&'a mut (A, B, C, D, E, F, G, H, I, J, K, L) as IntoParallelIterator>::Iter

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

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

type Iter = Iter<'a, T>

fn into_par_iter(self) -> <&'a LinkedList<T> as IntoParallelIterator>::Iter

fn into_par_iter( self) -> <(A, B, C, D, E, F, G, H, I, J, K) as IntoParallelIterator>::Iter

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

type Item = &'data T

type Iter = Iter<'data, T>

fn into_par_iter(self) -> <&'data [T] as IntoParallelIterator>::Iter ⓘ

fn into_par_iter( self) -> <&'a (A, B, C, D, E, F, G, H, I, J) as IntoParallelIterator>::Iter

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

type Item = &'a mut T

type Iter = IterMut<'a, T>

fn into_par_iter(self) -> <&'a mut Result<T, E> as IntoParallelIterator>::Iter

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

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

type Iter = IntoIter<T>

fn into_par_iter(self) -> <LinkedList<T> as IntoParallelIterator>::Iter

type Item = (<A as IntoParallelRefMutIterator<'a>>::Item, <B as IntoParallelRefMutIterator<'a>>::Item, <C as IntoParallelRefMutIterator<'a>>::Item, <D as IntoParallelRefMutIterator<'a>>::Item, <E as IntoParallelRefMutIterator<'a>>::Item, <F as IntoParallelRefMutIterator<'a>>::Item)

type Iter = MultiZip<(<A as IntoParallelRefMutIterator<'a>>::Iter, <B as IntoParallelRefMutIterator<'a>>::Iter, <C as IntoParallelRefMutIterator<'a>>::Iter, <D as IntoParallelRefMutIterator<'a>>::Iter, <E as IntoParallelRefMutIterator<'a>>::Iter, <F as IntoParallelRefMutIterator<'a>>::Iter)>

fn into_par_iter( self) -> <&'a mut (A, B, C, D, E, F) as IntoParallelIterator>::Iter

type Item = (<A as IntoParallelIterator>::Item, <B as IntoParallelIterator>::Item, <C as IntoParallelIterator>::Item, <D as IntoParallelIterator>::Item, <E as IntoParallelIterator>::Item)

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

fn into_par_iter(self) -> <(A, B, C, D, E) as IntoParallelIterator>::Iter

type Item = (<A as IntoParallelRefIterator<'a>>::Item, <B as IntoParallelRefIterator<'a>>::Item, <C as IntoParallelRefIterator<'a>>::Item, <D as IntoParallelRefIterator<'a>>::Item, <E as IntoParallelRefIterator<'a>>::Item)

type Iter = MultiZip<(<A as IntoParallelRefIterator<'a>>::Iter, <B as IntoParallelRefIterator<'a>>::Iter, <C as IntoParallelRefIterator<'a>>::Iter, <D as IntoParallelRefIterator<'a>>::Iter, <E as IntoParallelRefIterator<'a>>::Iter)>

fn into_par_iter(self) -> <&'a (A, B, C, D, E) as IntoParallelIterator>::Iter

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

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

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

fn into_par_iter( self) -> <&'a mut HashMap<K, V, S> as IntoParallelIterator>::Iter

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

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

type Iter = IntoIter<K, V>

fn into_par_iter(self) -> <HashMap<K, V, S> as IntoParallelIterator>::Iter

impl<T> IntoParallelIterator for VecDeque<T, Global>where T: Send,

type Item = T

type Iter = IntoIter<T>

fn into_par_iter(self) -> <VecDeque<T, Global> as IntoParallelIterator>::Iter

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

type Item = &'data T

type Iter = Iter<'data, T>

fn into_par_iter(self) -> <&'data [T; N] as IntoParallelIterator>::Iter

type Item = (<A as IntoParallelIterator>::Item, <B as IntoParallelIterator>::Item, <C as IntoParallelIterator>::Item, <D as IntoParallelIterator>::Item)

impl<T> IntoParallelIterator for BTreeSet<T, Global>where
T: Ord + Send,

fn into_par_iter(
self
) -> <&'a mut (A, B, C, D, E, F, G, H, I, J, K) as IntoParallelIterator>::Iter

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

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

fn into_par_iter(
self
) -> <&'a BTreeSet<T, Global> as IntoParallelIterator>::Iter

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

fn into_par_iter(
self
) -> <&'a (A, B, C, D, E, F, G, H, I) as IntoParallelIterator>::Iter

fn into_par_iter(
self
) -> <(A, B, C, D, E, F, G, H) as IntoParallelIterator>::Iter

fn into_par_iter(
self
) -> <&'a mut (A, B, C, D, E, F, G, H, I, J) as IntoParallelIterator>::Iter

fn into_par_iter(
self
) -> <&'a mut (A, B, C, D, E, F, G, H, I, J, K, L) as IntoParallelIterator>::Iter

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

fn into_par_iter(
self
) -> <(A, B, C, D, E, F, G, H, I, J, K) as IntoParallelIterator>::Iter

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

fn into_par_iter(
self
) -> <&'a (A, B, C, D, E, F, G, H, I, J) as IntoParallelIterator>::Iter

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

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

fn into_par_iter(
self
) -> <&'a mut (A, B, C, D, E, F) as IntoParallelIterator>::Iter

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

fn into_par_iter(
self
) -> <&'a mut HashMap<K, V, S> as IntoParallelIterator>::Iter

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

impl<T> IntoParallelIterator for VecDeque<T, Global>where
T: Send,

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

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

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

fn into_par_iter(
self
) -> <(A, B, C, D, E, F, G, H, I, J, K, L) as IntoParallelIterator>::Iter

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

fn into_par_iter(
self
) -> <&'a (A, B, C, D, E, F, G) as IntoParallelIterator>::Iter

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

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

fn into_par_iter(
self
) -> <&'a VecDeque<T, Global> as IntoParallelIterator>::Iter

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