[−][src]Trait valora::prelude::IntoParallelIterator

pub trait IntoParallelIterator where
    <Self::Iter as ParallelIterator>::Item == Self::Item, {
    type Iter: ParallelIterator;
    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`

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<'a, T> IntoParallelIterator for &'a Option<T> where T: Sync,` [src]

`type Item = &'a T`

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

`fn into_par_iter(self) -> <&'a Option<T> as IntoParallelIterator>::Iter`[src]

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

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

`type Iter = IntoIter<T>`

`fn into_par_iter(self) -> <LinkedList<T> as IntoParallelIterator>::Iter`[src]

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

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

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

`fn into_par_iter(self) -> <&'a (A, B, C, D) as IntoParallelIterator>::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, B: IntoParallelIterator, C: IntoParallelIterator, D: IntoParallelIterator, E: IntoParallelIterator, F: IntoParallelIterator, G: IntoParallelIterator, H: IntoParallelIterator, I: IntoParallelIterator, J: IntoParallelIterator, <A as IntoParallelIterator>::Iter: IndexedParallelIterator, ::Iter: IndexedParallelIterator, <C as IntoParallelIterator>::Iter: IndexedParallelIterator, <D as IntoParallelIterator>::Iter: IndexedParallelIterator, <E as IntoParallelIterator>::Iter: IndexedParallelIterator, <F as IntoParallelIterator>::Iter: IndexedParallelIterator, <G as IntoParallelIterator>::Iter: IndexedParallelIterator, <H as IntoParallelIterator>::Iter: IndexedParallelIterator, ::Iter: IndexedParallelIterator, <J as IntoParallelIterator>::Iter: IndexedParallelIterator, [src]

`type Item = (<A as IntoParallelIterator>::Item, ::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, ::Item, <J as IntoParallelIterator>::Item)`

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

`fn into_par_iter( self ) -> <(A, B, C, D, E, F, G, H, I, J) as IntoParallelIterator>::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>, B: IntoParallelRefIterator<'a>, C: IntoParallelRefIterator<'a>, D: IntoParallelRefIterator<'a>, E: IntoParallelRefIterator<'a>, F: IntoParallelRefIterator<'a>, G: IntoParallelRefIterator<'a>, H: IntoParallelRefIterator<'a>, I: IntoParallelRefIterator<'a>, <A as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, >::Iter: IndexedParallelIterator, <C as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <D as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <E as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <F as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <G as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <H as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, >::Iter: IndexedParallelIterator, [src]

`type Item = (<A as IntoParallelRefIterator<'a>>::Item, >::Item, <C as IntoParallelRefIterator<'a>>::Item, <D as IntoParallelRefIterator<'a>>::Item, <E as IntoParallelRefIterator<'a>>::Item, <F as IntoParallelRefIterator<'a>>::Item, <G as IntoParallelRefIterator<'a>>::Item, <H as IntoParallelRefIterator<'a>>::Item, >::Item)`

`type Iter = MultiZip<(<A as IntoParallelRefIterator<'a>>::Iter, >::Iter, <C as IntoParallelRefIterator<'a>>::Iter, <D as IntoParallelRefIterator<'a>>::Iter, <E as IntoParallelRefIterator<'a>>::Iter, <F as IntoParallelRefIterator<'a>>::Iter, <G as IntoParallelRefIterator<'a>>::Iter, <H as IntoParallelRefIterator<'a>>::Iter, >::Iter)>`

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

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

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

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

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

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

`type Item = &'a mut T`

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

`fn into_par_iter(self) -> <&'a mut Option<T> as IntoParallelIterator>::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>, B: IntoParallelRefMutIterator<'a>, C: IntoParallelRefMutIterator<'a>, D: IntoParallelRefMutIterator<'a>, E: IntoParallelRefMutIterator<'a>, F: IntoParallelRefMutIterator<'a>, G: IntoParallelRefMutIterator<'a>, H: IntoParallelRefMutIterator<'a>, I: IntoParallelRefMutIterator<'a>, <A as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, >::Iter: IndexedParallelIterator, <C as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <D as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <E as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <F as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <G as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <H as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, >::Iter: IndexedParallelIterator, [src]

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

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

`fn into_par_iter( self ) -> <&'a mut (A, B, C, D, E, F, G, H, I) as IntoParallelIterator>::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>, B: IntoParallelRefMutIterator<'a>, C: IntoParallelRefMutIterator<'a>, D: IntoParallelRefMutIterator<'a>, E: IntoParallelRefMutIterator<'a>, F: IntoParallelRefMutIterator<'a>, G: IntoParallelRefMutIterator<'a>, H: IntoParallelRefMutIterator<'a>, I: IntoParallelRefMutIterator<'a>, J: IntoParallelRefMutIterator<'a>, K: IntoParallelRefMutIterator<'a>, <A as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, >::Iter: IndexedParallelIterator, <C as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <D as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <E as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <F as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <G as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <H as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, >::Iter: IndexedParallelIterator, <J as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <K as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, [src]

type Item = (<A as IntoParallelRefMutIterator<'a>>::Item, >::Item, <C as IntoParallelRefMutIterator<'a>>::Item, <D as IntoParallelRefMutIterator<'a>>::Item, <E as IntoParallelRefMutIterator<'a>>::Item, <F as IntoParallelRefMutIterator<'a>>::Item, <G as IntoParallelRefMutIterator<'a>>::Item, <H as IntoParallelRefMutIterator<'a>>::Item, >::Item, <J as IntoParallelRefMutIterator<'a>>::Item, <K as IntoParallelRefMutIterator<'a>>::Item)

type Iter = MultiZip<(<A as IntoParallelRefMutIterator<'a>>::Iter, >::Iter, <C as IntoParallelRefMutIterator<'a>>::Iter, <D as IntoParallelRefMutIterator<'a>>::Iter, <E as IntoParallelRefMutIterator<'a>>::Iter, <F as IntoParallelRefMutIterator<'a>>::Iter, <G as IntoParallelRefMutIterator<'a>>::Iter, <H as IntoParallelRefMutIterator<'a>>::Iter, >::Iter, <J as IntoParallelRefMutIterator<'a>>::Iter, <K as IntoParallelRefMutIterator<'a>>::Iter)>

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

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

`type Item = T`

`type Iter = IntoIter<T>`

`fn into_par_iter(self) -> <Vec<T> as IntoParallelIterator>::Iter`[src]

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

`type Item = &'data mut T`

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

`fn into_par_iter(self) -> <&'data mut Vec<T> as IntoParallelIterator>::Iter`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`fn into_par_iter(self) -> <(A, B, C, D) as IntoParallelIterator>::Iter`[src]

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

`type Item = (<A as IntoParallelRefIterator<'a>>::Item, >::Item)`

`type Iter = MultiZip<(<A as IntoParallelRefIterator<'a>>::Iter, >::Iter)>`

`fn into_par_iter(self) -> <&'a (A, B) as IntoParallelIterator>::Iter`[src]

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

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

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

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

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

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

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

`fn into_par_iter(self) -> <&'a BTreeSet<T> as IntoParallelIterator>::Iter`[src]

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

`type Item = (<A as IntoParallelRefMutIterator<'a>>::Item,)`

`type Iter = MultiZip<(<A as IntoParallelRefMutIterator<'a>>::Iter,)>`

`fn into_par_iter(self) -> <&'a mut (A,) as IntoParallelIterator>::Iter`[src]

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

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

`type Iter = IntoIter<T>`

`fn into_par_iter(self) -> <BTreeSet<T> as IntoParallelIterator>::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>, B: IntoParallelRefMutIterator<'a>, C: IntoParallelRefMutIterator<'a>, D: IntoParallelRefMutIterator<'a>, E: IntoParallelRefMutIterator<'a>, F: IntoParallelRefMutIterator<'a>, G: IntoParallelRefMutIterator<'a>, H: IntoParallelRefMutIterator<'a>, I: IntoParallelRefMutIterator<'a>, J: IntoParallelRefMutIterator<'a>, <A as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, >::Iter: IndexedParallelIterator, <C as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <D as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <E as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <F as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <G as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <H as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, >::Iter: IndexedParallelIterator, <J as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, [src]

`type Item = (<A as IntoParallelRefMutIterator<'a>>::Item, >::Item, <C as IntoParallelRefMutIterator<'a>>::Item, <D as IntoParallelRefMutIterator<'a>>::Item, <E as IntoParallelRefMutIterator<'a>>::Item, <F as IntoParallelRefMutIterator<'a>>::Item, <G as IntoParallelRefMutIterator<'a>>::Item, <H as IntoParallelRefMutIterator<'a>>::Item, >::Item, <J as IntoParallelRefMutIterator<'a>>::Item)`

`type Iter = MultiZip<(<A as IntoParallelRefMutIterator<'a>>::Iter, >::Iter, <C as IntoParallelRefMutIterator<'a>>::Iter, <D as IntoParallelRefMutIterator<'a>>::Iter, <E as IntoParallelRefMutIterator<'a>>::Iter, <F as IntoParallelRefMutIterator<'a>>::Iter, <G as IntoParallelRefMutIterator<'a>>::Iter, <H as IntoParallelRefMutIterator<'a>>::Iter, >::Iter, <J as IntoParallelRefMutIterator<'a>>::Iter)>`

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

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

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

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

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

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

`type Item = (<A as IntoParallelRefMutIterator<'a>>::Item, >::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, >::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`[src]

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

`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`[src]

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

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

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

`fn into_par_iter(self) -> <&'a BTreeMap<K, V> as IntoParallelIterator>::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) -> <RangeInclusive<T> as IntoParallelIterator>::Iter`[src]

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

`type Item = (<A as IntoParallelIterator>::Item, ::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, ::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`[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>, B: IntoParallelRefIterator<'a>, C: IntoParallelRefIterator<'a>, D: IntoParallelRefIterator<'a>, E: IntoParallelRefIterator<'a>, F: IntoParallelRefIterator<'a>, G: IntoParallelRefIterator<'a>, H: IntoParallelRefIterator<'a>, <A as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, >::Iter: IndexedParallelIterator, <C as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <D as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <E as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <F as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <G as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <H as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, [src]

`type Item = (<A as IntoParallelRefIterator<'a>>::Item, >::Item, <C as IntoParallelRefIterator<'a>>::Item, <D as IntoParallelRefIterator<'a>>::Item, <E as IntoParallelRefIterator<'a>>::Item, <F as IntoParallelRefIterator<'a>>::Item, <G as IntoParallelRefIterator<'a>>::Item, <H as IntoParallelRefIterator<'a>>::Item)`

`type Iter = MultiZip<(<A as IntoParallelRefIterator<'a>>::Iter, >::Iter, <C as IntoParallelRefIterator<'a>>::Iter, <D as IntoParallelRefIterator<'a>>::Iter, <E as IntoParallelRefIterator<'a>>::Iter, <F as IntoParallelRefIterator<'a>>::Iter, <G as IntoParallelRefIterator<'a>>::Iter, <H as IntoParallelRefIterator<'a>>::Iter)>`

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

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

`type Item = (<A as IntoParallelIterator>::Item, ::Item)`

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

`fn into_par_iter(self) -> <(A, B) as IntoParallelIterator>::Iter`[src]

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

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

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

`fn into_par_iter(self) -> <&'a BinaryHeap<T> as IntoParallelIterator>::Iter`[src]

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

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

`type Iter = MultiZip<(<A as IntoParallelIterator>::Iter, ::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`[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>, B: IntoParallelRefIterator<'a>, C: IntoParallelRefIterator<'a>, D: IntoParallelRefIterator<'a>, E: IntoParallelRefIterator<'a>, F: IntoParallelRefIterator<'a>, G: IntoParallelRefIterator<'a>, H: IntoParallelRefIterator<'a>, I: IntoParallelRefIterator<'a>, J: IntoParallelRefIterator<'a>, K: IntoParallelRefIterator<'a>, <A as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, >::Iter: IndexedParallelIterator, <C as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <D as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <E as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <F as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <G as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <H as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, >::Iter: IndexedParallelIterator, <J as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <K as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, [src]

`type Item = (<A as IntoParallelRefIterator<'a>>::Item, >::Item, <C as IntoParallelRefIterator<'a>>::Item, <D as IntoParallelRefIterator<'a>>::Item, <E as IntoParallelRefIterator<'a>>::Item, <F as IntoParallelRefIterator<'a>>::Item, <G as IntoParallelRefIterator<'a>>::Item, <H as IntoParallelRefIterator<'a>>::Item, >::Item, <J as IntoParallelRefIterator<'a>>::Item, <K as IntoParallelRefIterator<'a>>::Item)`

`type Iter = MultiZip<(<A as IntoParallelRefIterator<'a>>::Iter, >::Iter, <C as IntoParallelRefIterator<'a>>::Iter, <D as IntoParallelRefIterator<'a>>::Iter, <E as IntoParallelRefIterator<'a>>::Iter, <F as IntoParallelRefIterator<'a>>::Iter, <G as IntoParallelRefIterator<'a>>::Iter, <H as IntoParallelRefIterator<'a>>::Iter, >::Iter, <J as IntoParallelRefIterator<'a>>::Iter, <K as IntoParallelRefIterator<'a>>::Iter)>`

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

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

`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`[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>, B: IntoParallelRefIterator<'a>, C: IntoParallelRefIterator<'a>, D: IntoParallelRefIterator<'a>, E: IntoParallelRefIterator<'a>, F: IntoParallelRefIterator<'a>, G: IntoParallelRefIterator<'a>, H: IntoParallelRefIterator<'a>, I: IntoParallelRefIterator<'a>, J: IntoParallelRefIterator<'a>, <A as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, >::Iter: IndexedParallelIterator, <C as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <D as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <E as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <F as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <G as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <H as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, >::Iter: IndexedParallelIterator, <J as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, [src]

`type Item = (<A as IntoParallelRefIterator<'a>>::Item, >::Item, <C as IntoParallelRefIterator<'a>>::Item, <D as IntoParallelRefIterator<'a>>::Item, <E as IntoParallelRefIterator<'a>>::Item, <F as IntoParallelRefIterator<'a>>::Item, <G as IntoParallelRefIterator<'a>>::Item, <H as IntoParallelRefIterator<'a>>::Item, >::Item, <J as IntoParallelRefIterator<'a>>::Item)`

`type Iter = MultiZip<(<A as IntoParallelRefIterator<'a>>::Iter, >::Iter, <C as IntoParallelRefIterator<'a>>::Iter, <D as IntoParallelRefIterator<'a>>::Iter, <E as IntoParallelRefIterator<'a>>::Iter, <F as IntoParallelRefIterator<'a>>::Iter, <G as IntoParallelRefIterator<'a>>::Iter, <H as IntoParallelRefIterator<'a>>::Iter, >::Iter, <J as IntoParallelRefIterator<'a>>::Iter)>`

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

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

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

`type Iter = MultiZip<(<A as IntoParallelIterator>::Iter, ::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`[src]

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

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

`type Iter = IntoIter<T>`

`fn into_par_iter(self) -> <VecDeque<T> as IntoParallelIterator>::Iter`[src]

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

`type Item = &'data T`

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

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

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

`type Item = (<A as IntoParallelIterator>::Item, ::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)`

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

`fn into_par_iter( self ) -> <(A, B, C, D, E, F, G, H) as IntoParallelIterator>::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>, B: IntoParallelRefMutIterator<'a>, C: IntoParallelRefMutIterator<'a>, D: IntoParallelRefMutIterator<'a>, E: IntoParallelRefMutIterator<'a>, F: IntoParallelRefMutIterator<'a>, G: IntoParallelRefMutIterator<'a>, H: IntoParallelRefMutIterator<'a>, <A as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, >::Iter: IndexedParallelIterator, <C as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <D as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <E as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <F as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <G as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <H as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, [src]

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

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

`fn into_par_iter( self ) -> <&'a mut (A, B, C, D, E, F, G, H) as IntoParallelIterator>::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, B: IntoParallelIterator, C: IntoParallelIterator, D: IntoParallelIterator, E: IntoParallelIterator, F: IntoParallelIterator, G: IntoParallelIterator, H: IntoParallelIterator, I: IntoParallelIterator, <A as IntoParallelIterator>::Iter: IndexedParallelIterator, ::Iter: IndexedParallelIterator, <C as IntoParallelIterator>::Iter: IndexedParallelIterator, <D as IntoParallelIterator>::Iter: IndexedParallelIterator, <E as IntoParallelIterator>::Iter: IndexedParallelIterator, <F as IntoParallelIterator>::Iter: IndexedParallelIterator, <G as IntoParallelIterator>::Iter: IndexedParallelIterator, <H as IntoParallelIterator>::Iter: IndexedParallelIterator, ::Iter: IndexedParallelIterator, [src]

`type Item = (<A as IntoParallelIterator>::Item, ::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, ::Item)`

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

`fn into_par_iter( self ) -> <(A, B, C, D, E, F, G, H, I) as IntoParallelIterator>::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>, B: IntoParallelRefIterator<'a>, C: IntoParallelRefIterator<'a>, D: IntoParallelRefIterator<'a>, E: IntoParallelRefIterator<'a>, F: IntoParallelRefIterator<'a>, G: IntoParallelRefIterator<'a>, <A as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, >::Iter: IndexedParallelIterator, <C as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <D as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <E as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <F as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <G as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, [src]

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

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

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

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

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

`type Iter = MultiZip<(<A as IntoParallelRefIterator<'a>>::Iter, >::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`[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>, B: IntoParallelRefMutIterator<'a>, C: IntoParallelRefMutIterator<'a>, D: IntoParallelRefMutIterator<'a>, E: IntoParallelRefMutIterator<'a>, F: IntoParallelRefMutIterator<'a>, G: IntoParallelRefMutIterator<'a>, H: IntoParallelRefMutIterator<'a>, I: IntoParallelRefMutIterator<'a>, J: IntoParallelRefMutIterator<'a>, K: IntoParallelRefMutIterator<'a>, L: IntoParallelRefMutIterator<'a>, <A as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, >::Iter: IndexedParallelIterator, <C as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <D as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <E as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <F as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <G as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <H as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, >::Iter: IndexedParallelIterator, <J as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <K as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <L as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, [src]

type Item = (<A as IntoParallelRefMutIterator<'a>>::Item, >::Item, <C as IntoParallelRefMutIterator<'a>>::Item, <D as IntoParallelRefMutIterator<'a>>::Item, <E as IntoParallelRefMutIterator<'a>>::Item, <F as IntoParallelRefMutIterator<'a>>::Item, <G as IntoParallelRefMutIterator<'a>>::Item, <H as IntoParallelRefMutIterator<'a>>::Item, >::Item, <J as IntoParallelRefMutIterator<'a>>::Item, <K as IntoParallelRefMutIterator<'a>>::Item, <L as IntoParallelRefMutIterator<'a>>::Item)

type Iter = MultiZip<(<A as IntoParallelRefMutIterator<'a>>::Iter, >::Iter, <C as IntoParallelRefMutIterator<'a>>::Iter, <D as IntoParallelRefMutIterator<'a>>::Iter, <E as IntoParallelRefMutIterator<'a>>::Iter, <F as IntoParallelRefMutIterator<'a>>::Iter, <G as IntoParallelRefMutIterator<'a>>::Iter, <H as IntoParallelRefMutIterator<'a>>::Iter, >::Iter, <J as IntoParallelRefMutIterator<'a>>::Iter, <K as IntoParallelRefMutIterator<'a>>::Iter, <L as IntoParallelRefMutIterator<'a>>::Iter)>

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

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

`type Item = T`

`type Iter = IntoIter<T>`

`fn into_par_iter(self) -> <Result<T, E> as IntoParallelIterator>::Iter`[src]

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

`type Item = T`

`type Iter = IntoIter<T>`

`fn into_par_iter(self) -> <Option<T> as IntoParallelIterator>::Iter`[src]

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

`type Item = &'a T`

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

`fn into_par_iter(self) -> <&'a Result<T, E> as IntoParallelIterator>::Iter`[src]

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

`type Item = &'a mut T`

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

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

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

`type Item = &'data mut T`

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

`fn into_par_iter(self) -> <&'data mut [T] as IntoParallelIterator>::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) -> <Range<T> as IntoParallelIterator>::Iter`[src]

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

`type Item = (<A as IntoParallelRefMutIterator<'a>>::Item, >::Item)`

`type Iter = MultiZip<(<A as IntoParallelRefMutIterator<'a>>::Iter, >::Iter)>`

`fn into_par_iter(self) -> <&'a mut (A, B) as IntoParallelIterator>::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, B: IntoParallelIterator, C: IntoParallelIterator, D: IntoParallelIterator, E: IntoParallelIterator, F: IntoParallelIterator, G: IntoParallelIterator, H: IntoParallelIterator, I: IntoParallelIterator, J: IntoParallelIterator, K: IntoParallelIterator, <A as IntoParallelIterator>::Iter: IndexedParallelIterator, ::Iter: IndexedParallelIterator, <C as IntoParallelIterator>::Iter: IndexedParallelIterator, <D as IntoParallelIterator>::Iter: IndexedParallelIterator, <E as IntoParallelIterator>::Iter: IndexedParallelIterator, <F as IntoParallelIterator>::Iter: IndexedParallelIterator, <G as IntoParallelIterator>::Iter: IndexedParallelIterator, <H as IntoParallelIterator>::Iter: IndexedParallelIterator, ::Iter: IndexedParallelIterator, <J as IntoParallelIterator>::Iter: IndexedParallelIterator, <K as IntoParallelIterator>::Iter: IndexedParallelIterator, [src]

`type Item = (<A as IntoParallelIterator>::Item, ::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, ::Item, <J as IntoParallelIterator>::Item, <K as IntoParallelIterator>::Item)`

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

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

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

`type Item = (<A as IntoParallelRefIterator<'a>>::Item, >::Item, <C as IntoParallelRefIterator<'a>>::Item)`

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

`fn into_par_iter(self) -> <&'a (A, B, C) as IntoParallelIterator>::Iter`[src]

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

`type Item = &'a T`

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

`fn into_par_iter(self) -> <&'a VecDeque<T> as IntoParallelIterator>::Iter`[src]

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

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

`type Iter = IntoIter<K, V>`

`fn into_par_iter(self) -> <BTreeMap<K, V> as IntoParallelIterator>::Iter`[src]

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

`type Item = (<A as IntoParallelIterator>::Item,)`

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

`fn into_par_iter(self) -> <(A,) as IntoParallelIterator>::Iter`[src]

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

`type Item = &'a mut T`

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

`fn into_par_iter(self) -> <&'a mut VecDeque<T> as IntoParallelIterator>::Iter`[src]

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

`type Item = &'data T`

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

`fn into_par_iter(self) -> <&'data Vec<T> as IntoParallelIterator>::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>, B: IntoParallelRefIterator<'a>, C: IntoParallelRefIterator<'a>, D: IntoParallelRefIterator<'a>, E: IntoParallelRefIterator<'a>, F: IntoParallelRefIterator<'a>, G: IntoParallelRefIterator<'a>, H: IntoParallelRefIterator<'a>, I: IntoParallelRefIterator<'a>, J: IntoParallelRefIterator<'a>, K: IntoParallelRefIterator<'a>, L: IntoParallelRefIterator<'a>, <A as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, >::Iter: IndexedParallelIterator, <C as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <D as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <E as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <F as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <G as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <H as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, >::Iter: IndexedParallelIterator, <J as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <K as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, <L as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator, [src]

type Item = (<A as IntoParallelRefIterator<'a>>::Item, >::Item, <C as IntoParallelRefIterator<'a>>::Item, <D as IntoParallelRefIterator<'a>>::Item, <E as IntoParallelRefIterator<'a>>::Item, <F as IntoParallelRefIterator<'a>>::Item, <G as IntoParallelRefIterator<'a>>::Item, <H as IntoParallelRefIterator<'a>>::Item, >::Item, <J as IntoParallelRefIterator<'a>>::Item, <K as IntoParallelRefIterator<'a>>::Item, <L as IntoParallelRefIterator<'a>>::Item)

type Iter = MultiZip<(<A as IntoParallelRefIterator<'a>>::Iter, >::Iter, <C as IntoParallelRefIterator<'a>>::Iter, <D as IntoParallelRefIterator<'a>>::Iter, <E as IntoParallelRefIterator<'a>>::Iter, <F as IntoParallelRefIterator<'a>>::Iter, <G as IntoParallelRefIterator<'a>>::Iter, <H as IntoParallelRefIterator<'a>>::Iter, >::Iter, <J as IntoParallelRefIterator<'a>>::Iter, <K as IntoParallelRefIterator<'a>>::Iter, <L as IntoParallelRefIterator<'a>>::Iter)>

`fn into_par_iter( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L) as IntoParallelIterator>::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>, B: IntoParallelRefMutIterator<'a>, C: IntoParallelRefMutIterator<'a>, D: IntoParallelRefMutIterator<'a>, E: IntoParallelRefMutIterator<'a>, F: IntoParallelRefMutIterator<'a>, G: IntoParallelRefMutIterator<'a>, <A as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, >::Iter: IndexedParallelIterator, <C as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <D as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <E as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <F as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, <G as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator, [src]

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

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

`fn into_par_iter( self ) -> <&'a mut (A, B, C, D, E, F, G) as IntoParallelIterator>::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, B: IntoParallelIterator, C: IntoParallelIterator, D: IntoParallelIterator, E: IntoParallelIterator, F: IntoParallelIterator, G: IntoParallelIterator, H: IntoParallelIterator, I: IntoParallelIterator, J: IntoParallelIterator, K: IntoParallelIterator, L: IntoParallelIterator, <A as IntoParallelIterator>::Iter: IndexedParallelIterator, ::Iter: IndexedParallelIterator, <C as IntoParallelIterator>::Iter: IndexedParallelIterator, <D as IntoParallelIterator>::Iter: IndexedParallelIterator, <E as IntoParallelIterator>::Iter: IndexedParallelIterator, <F as IntoParallelIterator>::Iter: IndexedParallelIterator, <G as IntoParallelIterator>::Iter: IndexedParallelIterator, <H as IntoParallelIterator>::Iter: IndexedParallelIterator, ::Iter: IndexedParallelIterator, <J as IntoParallelIterator>::Iter: IndexedParallelIterator, <K as IntoParallelIterator>::Iter: IndexedParallelIterator, <L as IntoParallelIterator>::Iter: IndexedParallelIterator, [src]

`type Item = (<A as IntoParallelIterator>::Item, ::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, ::Item, <J as IntoParallelIterator>::Item, <K as IntoParallelIterator>::Item, <L as IntoParallelIterator>::Item)`

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

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

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

`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`[src]

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

`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`[src]

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

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

`type Iter = IntoIter<T>`

`fn into_par_iter(self) -> <HashSet<T, S> as IntoParallelIterator>::Iter`[src]

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

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

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

`fn into_par_iter(self) -> <(A, B, C) as IntoParallelIterator>::Iter`[src]

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

`type Item = (<A as IntoParallelRefIterator<'a>>::Item,)`

`type Iter = MultiZip<(<A as IntoParallelRefIterator<'a>>::Iter,)>`

`fn into_par_iter(self) -> <&'a (A,) as IntoParallelIterator>::Iter`[src]

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

`type Item = T`

`type Iter = IntoIter<T>`

`fn into_par_iter(self) -> <BinaryHeap<T> as IntoParallelIterator>::Iter`[src]

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

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

`type Iter = MultiZip<(<A as IntoParallelRefMutIterator<'a>>::Iter, >::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`[src]

Loading content...

Implementors

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

`type Iter = T`

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

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

Loading content...

[−][src]Trait valora::prelude::IntoParallelIterator

Associated Types

type Iter: ParallelIterator

type Item: Send

Required methods

fn into_par_iter(self) -> Self::Iter

Examples

Implementations on Foreign Types

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

type Item = &'a T

type Iter = Iter<'a, T>

fn into_par_iter(self) -> <&'a Option<T> as IntoParallelIterator>::Iter[src]

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

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

type Iter = IntoIter<T>

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

type Item = (<A as IntoParallelRefIterator<'a>>::Item, <B as IntoParallelRefIterator<'a>>::Item, <C as IntoParallelRefIterator<'a>>::Item, <D 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)>

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

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

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

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, <F 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, <F as IntoParallelRefIterator<'a>>::Iter)>

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

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

type Item = &'a mut T

type Iter = IterMut<'a, T>

fn into_par_iter(self) -> <&'a mut Option<T> as IntoParallelIterator>::Iter[src]

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

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

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

type Item = T

type Iter = IntoIter<T>

fn into_par_iter(self) -> <Vec<T> as IntoParallelIterator>::Iter[src]

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

type Item = &'data mut T

type Iter = IterMut<'data, T>

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

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

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

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

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

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

type Iter = Iter<'a, T>

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

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

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

type Iter = Iter<'a, T>

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

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

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

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

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

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

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

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

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)

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

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

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

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

type Iter = Iter<'a, T>

fn into_par_iter(self) -> <&'a BTreeSet<T> as IntoParallelIterator>::Iter[src]

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

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

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

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

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

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

type Iter = IntoIter<T>

fn into_par_iter(self) -> <BTreeSet<T> as IntoParallelIterator>::Iter[src]

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

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

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

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

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

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[src]

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

`type Iter: ParallelIterator`

`type Item: Send`

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

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

`type Item = &'a T`

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

`fn into_par_iter(self) -> <&'a Option<T> as IntoParallelIterator>::Iter`[src]

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

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

`type Iter = IntoIter<T>`

`fn into_par_iter(self) -> <LinkedList<T> as IntoParallelIterator>::Iter`[src]

`type Item = (<A as IntoParallelRefIterator<'a>>::Item, <B as IntoParallelRefIterator<'a>>::Item, <C as IntoParallelRefIterator<'a>>::Item, <D 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)>`

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

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

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

`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, <F 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, <F as IntoParallelRefIterator<'a>>::Iter)>`

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

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

`type Item = &'a mut T`

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

`fn into_par_iter(self) -> <&'a mut Option<T> as IntoParallelIterator>::Iter`[src]

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

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

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

`type Item = T`

`type Iter = IntoIter<T>`

`fn into_par_iter(self) -> <Vec<T> as IntoParallelIterator>::Iter`[src]

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

`type Item = &'data mut T`

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

`fn into_par_iter(self) -> <&'data mut Vec<T> as IntoParallelIterator>::Iter`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

`fn into_par_iter(self) -> <(A, B, C, D) as IntoParallelIterator>::Iter`[src]

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

`type Item = (<A as IntoParallelRefIterator<'a>>::Item, <B as IntoParallelRefIterator<'a>>::Item)`

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

`fn into_par_iter(self) -> <&'a (A, B) as IntoParallelIterator>::Iter`[src]

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

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

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

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

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

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

`fn into_par_iter(self) -> <&'a BTreeSet<T> as IntoParallelIterator>::Iter`[src]

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

`type Item = (<A as IntoParallelRefMutIterator<'a>>::Item,)`

`type Iter = MultiZip<(<A as IntoParallelRefMutIterator<'a>>::Iter,)>`

`fn into_par_iter(self) -> <&'a mut (A,) as IntoParallelIterator>::Iter`[src]

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

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

`type Iter = IntoIter<T>`

`fn into_par_iter(self) -> <BTreeSet<T> as IntoParallelIterator>::Iter`[src]

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

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

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

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

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

`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`[src]

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

`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`[src]

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

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