Trait birli::IntoParallelIterator

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

    // Required method
    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§

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.

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

fn into_par_iter( self ) -> <&'a ArrayBase<OwnedArcRepr<A>, D> as IntoParallelIterator>::Iter

source §

impl<'a, A, D> IntoParallelIterator for AxisIter<'a, A, D>where D: Dimension, A: Sync,

Implemented for ranges of all primitive integer types and char.

§

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

Implementors§

§

impl<T> IntoParallelIterator for Twhere T: ParallelIterator,

§

type Iter = T

§

Trait birli::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<'a, A, D> IntoParallelIterator for AxisChunksIter<'a, A, D>where D: Dimension, A: Sync,

type Item = <AxisChunksIter<'a, A, D> as Iterator>::Item

type Iter = Parallel<AxisChunksIter<'a, A, D>>

fn into_par_iter( self ) -> <AxisChunksIter<'a, A, D> as IntoParallelIterator>::Iter

impl<'a, A, D> IntoParallelIterator for ArrayBase<ViewRepr<&'a mut A>, D>where D: Dimension, A: Sync + Send,

type Item = <ArrayBase<ViewRepr<&'a mut A>, D> as IntoIterator>::Item

type Iter = Parallel<ArrayBase<ViewRepr<&'a mut A>, D>>

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

impl<'a, A, D> IntoParallelIterator for &'a ArrayBase<OwnedArcRepr<A>, D>where D: Dimension, A: Sync,

type Item = &'a A

type Iter = Parallel<ArrayBase<ViewRepr<&'a A>, D>>

fn into_par_iter( self ) -> <&'a ArrayBase<OwnedArcRepr<A>, D> as IntoParallelIterator>::Iter

impl<'a, A, D> IntoParallelIterator for AxisIter<'a, A, D>where D: Dimension, A: Sync,

type Item = <AxisIter<'a, A, D> as Iterator>::Item

type Iter = Parallel<AxisIter<'a, A, D>>

fn into_par_iter(self) -> <AxisIter<'a, A, D> as IntoParallelIterator>::Iter

type Item = (<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item, <P6 as NdProducer>::Item)

type Iter = Parallel<Zip<(P1, P2, P3, P4, P5, P6), D>>

fn into_par_iter( self ) -> <Zip<(P1, P2, P3, P4, P5, P6), D> as IntoParallelIterator>::Iter

impl<'a, A, D> IntoParallelIterator for &'a mut ArrayBase<OwnedRepr<A>, D>where D: Dimension, A: Sync + Send,

type Item = &'a mut A

type Iter = Parallel<ArrayBase<ViewRepr<&'a mut A>, D>>

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

impl<D, P1> IntoParallelIterator for Zip<(P1,), D>where <P1 as NdProducer>::Item: Send, P1: Send + NdProducer<Dim = D>, D: Dimension,

type Item = (<P1 as NdProducer>::Item,)

type Iter = Parallel<Zip<(P1,), D>>

fn into_par_iter(self) -> <Zip<(P1,), D> as IntoParallelIterator>::Iter

impl<'a, A, D> IntoParallelIterator for AxisIterMut<'a, A, D>where D: Dimension, A: Send + Sync,

type Item = <AxisIterMut<'a, A, D> as Iterator>::Item

type Iter = Parallel<AxisIterMut<'a, A, D>>

fn into_par_iter(self) -> <AxisIterMut<'a, A, D> as IntoParallelIterator>::Iter

impl<'a, A, D> IntoParallelIterator for &'a mut ArrayBase<OwnedArcRepr<A>, D>where D: Dimension, A: Sync + Send + Clone,

type Item = &'a mut A

type Iter = Parallel<ArrayBase<ViewRepr<&'a mut A>, D>>

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

impl<'a, A, D> IntoParallelIterator for &'a ArrayBase<OwnedRepr<A>, D>where D: Dimension, A: Sync,

type Item = &'a A

type Iter = Parallel<ArrayBase<ViewRepr<&'a A>, D>>

fn into_par_iter( self ) -> <&'a ArrayBase<OwnedRepr<A>, D> as IntoParallelIterator>::Iter

type Item = (<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item, <P5 as NdProducer>::Item)

type Iter = Parallel<Zip<(P1, P2, P3, P4, P5), D>>

fn into_par_iter( self ) -> <Zip<(P1, P2, P3, P4, P5), D> as IntoParallelIterator>::Iter

impl<D, P1, P2> IntoParallelIterator for Zip<(P1, P2), D>where <P1 as NdProducer>::Item: Send, <P2 as NdProducer>::Item: Send, P1: Send + NdProducer<Dim = D>, P2: Send + NdProducer<Dim = D>, D: Dimension,

type Item = (<P1 as NdProducer>::Item, <P2 as NdProducer>::Item)

type Iter = Parallel<Zip<(P1, P2), D>>

fn into_par_iter(self) -> <Zip<(P1, P2), D> as IntoParallelIterator>::Iter

impl<D, P1, P2, P3> IntoParallelIterator for Zip<(P1, P2, P3), D>where <P1 as NdProducer>::Item: Send, <P2 as NdProducer>::Item: Send, <P3 as NdProducer>::Item: Send, P1: Send + NdProducer<Dim = D>, P2: Send + NdProducer<Dim = D>, P3: Send + NdProducer<Dim = D>, D: Dimension,

type Item = (<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item)

type Iter = Parallel<Zip<(P1, P2, P3), D>>

fn into_par_iter(self) -> <Zip<(P1, P2, P3), D> as IntoParallelIterator>::Iter

impl<'a, A, D> IntoParallelIterator for ArrayBase<ViewRepr<&'a A>, D>where D: Dimension, A: Sync,

type Item = <ArrayBase<ViewRepr<&'a A>, D> as IntoIterator>::Item

type Iter = Parallel<ArrayBase<ViewRepr<&'a A>, D>>

fn into_par_iter( self ) -> <ArrayBase<ViewRepr<&'a A>, D> as IntoParallelIterator>::Iter

impl<'a, A, D> IntoParallelIterator for AxisChunksIterMut<'a, A, D>where D: Dimension, A: Send + Sync,

type Item = <AxisChunksIterMut<'a, A, D> as Iterator>::Item

type Iter = Parallel<AxisChunksIterMut<'a, A, D>>

fn into_par_iter( self ) -> <AxisChunksIterMut<'a, A, D> as IntoParallelIterator>::Iter

type Item = (<P1 as NdProducer>::Item, <P2 as NdProducer>::Item, <P3 as NdProducer>::Item, <P4 as NdProducer>::Item)

type Iter = Parallel<Zip<(P1, P2, P3, P4), D>>

fn into_par_iter( self ) -> <Zip<(P1, P2, P3, P4), D> as IntoParallelIterator>::Iter

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

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

type Iter = Iter<'a, T>

fn into_par_iter( self ) -> <&'a BinaryHeap<T, Global> 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)

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

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

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

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

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

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