pub trait IntoParallelIterator {
type Iter: ParallelIterator
where
<Self::Iter as 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.
Associated Types
type Iter: ParallelIterator
where
<Self::Iter as ParallelIterator>::Item == Self::Item
type Iter: ParallelIterator
where
<Self::Iter as ParallelIterator>::Item == Self::Item
The parallel iterator type that will be created.
Required methods
fn into_par_iter(self) -> Self::Iter
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)]);
Implementations on Foreign Types
sourceimpl<T, S, A> IntoParallelIterator for HashSet<T, S, A> where
T: Send,
A: Allocator + Clone + Send,
impl<T, S, A> IntoParallelIterator for HashSet<T, S, A> where
T: Send,
A: Allocator + Clone + Send,
type Item = T
type Iter = IntoParIter<T, A>
fn into_par_iter(self) -> <HashSet<T, S, A> as IntoParallelIterator>::Iter
sourceimpl<'a, T, S, A> IntoParallelIterator for &'a HashSet<T, S, A> where
T: Sync,
A: Allocator + Clone,
impl<'a, T, S, A> IntoParallelIterator for &'a HashSet<T, S, A> where
T: Sync,
A: Allocator + Clone,
type Item = &'a T
type Iter = ParIter<'a, T>
fn into_par_iter(self) -> <&'a HashSet<T, S, A> as IntoParallelIterator>::Iter
sourceimpl<'a, K, V, S, A> IntoParallelIterator for &'a HashMap<K, V, S, A> where
K: Sync,
V: Sync,
A: Allocator + Clone,
impl<'a, K, V, S, A> IntoParallelIterator for &'a HashMap<K, V, S, A> where
K: Sync,
V: Sync,
A: Allocator + Clone,
sourceimpl<'a, K, V, S, A> IntoParallelIterator for &'a mut HashMap<K, V, S, A> where
K: Sync,
V: Send,
A: Allocator + Clone,
impl<'a, K, V, S, A> IntoParallelIterator for &'a mut HashMap<K, V, S, A> where
K: Sync,
V: Send,
A: Allocator + Clone,
type Item = (&'a K, &'a mut V)
type Iter = ParIterMut<'a, K, V>
fn into_par_iter(
self
) -> <&'a mut HashMap<K, V, S, A> as IntoParallelIterator>::Iter
sourceimpl<K, V, S, A> IntoParallelIterator for HashMap<K, V, S, A> where
K: Send,
V: Send,
A: Allocator + Clone + Send,
impl<K, V, S, A> IntoParallelIterator for HashMap<K, V, S, A> where
K: Send,
V: Send,
A: Allocator + Clone + Send,
type Item = (K, V)
type Iter = IntoParIter<K, V, A>
fn into_par_iter(self) -> <HashMap<K, V, S, A> as IntoParallelIterator>::Iter
sourceimpl<'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,
<B as IntoParallelRefIterator<'a>>::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,
<I as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
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,
<B as IntoParallelRefIterator<'a>>::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,
<I as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
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, <G as IntoParallelRefIterator<'a>>::Item, <H as IntoParallelRefIterator<'a>>::Item, <I 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, <G as IntoParallelRefIterator<'a>>::Iter, <H as IntoParallelRefIterator<'a>>::Iter, <I as IntoParallelRefIterator<'a>>::Iter)>
fn into_par_iter(
self
) -> <&'a (A, B, C, D, E, F, G, H, I) as IntoParallelIterator>::Iter
sourceimpl<'data, T, const N: usize> IntoParallelIterator for &'data [T; N] where
T: 'data + Sync,
impl<'data, T, const N: usize> IntoParallelIterator for &'data [T; N] where
T: 'data + Sync,
This implementation requires const generics, stabilized in Rust 1.51.
type Item = &'data T
type Iter = Iter<'data, T>
fn into_par_iter(self) -> <&'data [T; N] as IntoParallelIterator>::Iter
sourceimpl<'a, T> IntoParallelIterator for &'a mut Option<T> where
T: Send,
impl<'a, T> IntoParallelIterator for &'a mut Option<T> where
T: Send,
type Item = &'a mut T
type Iter = IterMut<'a, T>
fn into_par_iter(self) -> <&'a mut Option<T> as IntoParallelIterator>::Iter
sourceimpl<'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,
<B as IntoParallelRefIterator<'a>>::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,
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,
<B as IntoParallelRefIterator<'a>>::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,
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
sourceimpl<T> IntoParallelIterator for Range<T> where
Iter<T>: ParallelIterator,
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) -> <Range<T> as IntoParallelIterator>::Iter
sourceimpl<T, E> IntoParallelIterator for Result<T, E> where
T: Send,
impl<T, E> IntoParallelIterator for Result<T, E> where
T: Send,
type Item = T
type Iter = IntoIter<T>
fn into_par_iter(self) -> <Result<T, E> as IntoParallelIterator>::Iter
sourceimpl<'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,
<B as IntoParallelRefMutIterator<'a>>::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,
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,
<B as IntoParallelRefMutIterator<'a>>::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,
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
sourceimpl<'a, K, V, S> IntoParallelIterator for &'a mut HashMap<K, V, S> where
K: Hash + Eq + Sync,
V: Send,
S: BuildHasher,
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
sourceimpl<A, B, C, D> IntoParallelIterator for (A, B, C, D) where
A: IntoParallelIterator,
B: IntoParallelIterator,
C: IntoParallelIterator,
D: IntoParallelIterator,
<A as IntoParallelIterator>::Iter: IndexedParallelIterator,
<B as IntoParallelIterator>::Iter: IndexedParallelIterator,
<C as IntoParallelIterator>::Iter: IndexedParallelIterator,
<D as IntoParallelIterator>::Iter: IndexedParallelIterator,
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,
<B as IntoParallelIterator>::Iter: IndexedParallelIterator,
<C as IntoParallelIterator>::Iter: IndexedParallelIterator,
<D as IntoParallelIterator>::Iter: IndexedParallelIterator,
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
sourceimpl<'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,
<B as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
<C as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
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,
<B as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
<C as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
type Item = (<A as IntoParallelRefIterator<'a>>::Item, <B as IntoParallelRefIterator<'a>>::Item, <C as IntoParallelRefIterator<'a>>::Item)
type Iter = MultiZip<(<A as IntoParallelRefIterator<'a>>::Iter, <B as IntoParallelRefIterator<'a>>::Iter, <C as IntoParallelRefIterator<'a>>::Iter)>
fn into_par_iter(self) -> <&'a (A, B, C) as IntoParallelIterator>::Iter
sourceimpl<'a, K, V> IntoParallelIterator for &'a mut BTreeMap<K, V> where
K: Ord + Sync,
V: Send,
impl<'a, K, V> IntoParallelIterator for &'a mut BTreeMap<K, V> where
K: Ord + Sync,
V: Send,
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
sourceimpl<T> IntoParallelIterator for VecDeque<T, Global> where
T: Send,
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
sourceimpl<'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,
<B as IntoParallelRefIterator<'a>>::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,
<I as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
<J as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
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,
<B as IntoParallelRefIterator<'a>>::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,
<I as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
<J as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
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, <G as IntoParallelRefIterator<'a>>::Item, <H as IntoParallelRefIterator<'a>>::Item, <I as IntoParallelRefIterator<'a>>::Item, <J 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, <G as IntoParallelRefIterator<'a>>::Iter, <H as IntoParallelRefIterator<'a>>::Iter, <I as IntoParallelRefIterator<'a>>::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
sourceimpl<'a, T> IntoParallelIterator for &'a Option<T> where
T: Sync,
impl<'a, T> IntoParallelIterator for &'a Option<T> where
T: Sync,
type Item = &'a T
type Iter = Iter<'a, T>
fn into_par_iter(self) -> <&'a Option<T> as IntoParallelIterator>::Iter
sourceimpl<'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,
<B as IntoParallelRefMutIterator<'a>>::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,
<I as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
<J as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
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,
<B as IntoParallelRefMutIterator<'a>>::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,
<I as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
<J as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
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, <G as IntoParallelRefMutIterator<'a>>::Item, <H as IntoParallelRefMutIterator<'a>>::Item, <I as IntoParallelRefMutIterator<'a>>::Item, <J 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, <G as IntoParallelRefMutIterator<'a>>::Iter, <H as IntoParallelRefMutIterator<'a>>::Iter, <I as IntoParallelRefMutIterator<'a>>::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
sourceimpl<'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,
<B as IntoParallelRefMutIterator<'a>>::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,
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,
<B as IntoParallelRefMutIterator<'a>>::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,
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, <G as IntoParallelRefMutIterator<'a>>::Item, <H 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, <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
sourceimpl<T> IntoParallelIterator for RangeInclusive<T> where
Iter<T>: ParallelIterator,
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) -> <RangeInclusive<T> as IntoParallelIterator>::Iter
sourceimpl<T, const N: usize> IntoParallelIterator for [T; N] where
T: Send,
impl<T, const N: usize> IntoParallelIterator for [T; N] where
T: Send,
This implementation requires const generics, stabilized in Rust 1.51.
type Item = T
type Iter = IntoIter<T, N>
fn into_par_iter(self) -> <[T; N] as IntoParallelIterator>::Iter
sourceimpl<T> IntoParallelIterator for Vec<T, Global> where
T: Send,
impl<T> IntoParallelIterator for Vec<T, Global> where
T: Send,
sourceimpl<'a, A, B> IntoParallelIterator for &'a mut (A, B) where
A: IntoParallelRefMutIterator<'a>,
B: IntoParallelRefMutIterator<'a>,
<A as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
<B as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
impl<'a, A, B> IntoParallelIterator for &'a mut (A, B) where
A: IntoParallelRefMutIterator<'a>,
B: IntoParallelRefMutIterator<'a>,
<A as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
<B as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
type Item = (<A as IntoParallelRefMutIterator<'a>>::Item, <B as IntoParallelRefMutIterator<'a>>::Item)
type Iter = MultiZip<(<A as IntoParallelRefMutIterator<'a>>::Iter, <B as IntoParallelRefMutIterator<'a>>::Iter)>
fn into_par_iter(self) -> <&'a mut (A, B) as IntoParallelIterator>::Iter
sourceimpl<T> IntoParallelIterator for BinaryHeap<T> where
T: Ord + Send,
impl<T> IntoParallelIterator for BinaryHeap<T> where
T: Ord + Send,
type Item = T
type Iter = IntoIter<T>
fn into_par_iter(self) -> <BinaryHeap<T> as IntoParallelIterator>::Iter
sourceimpl<'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,
<B as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
<C as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
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,
<B as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
<C as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
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
sourceimpl<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,
<B as IntoParallelIterator>::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,
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,
<B as IntoParallelIterator>::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,
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)
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, <H as IntoParallelIterator>::Iter)>
fn into_par_iter(
self
) -> <(A, B, C, D, E, F, G, H) as IntoParallelIterator>::Iter
sourceimpl<'a, T> IntoParallelIterator for &'a LinkedList<T> where
T: Sync,
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
sourceimpl<'a, T> IntoParallelIterator for &'a BTreeSet<T> where
T: Ord + Sync,
impl<'a, T> IntoParallelIterator for &'a BTreeSet<T> where
T: Ord + Sync,
type Item = <&'a BTreeSet<T> as IntoIterator>::Item
type Iter = Iter<'a, T>
fn into_par_iter(self) -> <&'a BTreeSet<T> as IntoParallelIterator>::Iter
sourceimpl<'data, T> IntoParallelIterator for &'data [T] where
T: 'data + Sync,
impl<'data, T> IntoParallelIterator for &'data [T] where
T: 'data + Sync,
sourceimpl<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,
<B as IntoParallelIterator>::Iter: IndexedParallelIterator,
<C as IntoParallelIterator>::Iter: IndexedParallelIterator,
<D as IntoParallelIterator>::Iter: IndexedParallelIterator,
<E as IntoParallelIterator>::Iter: IndexedParallelIterator,
<F as IntoParallelIterator>::Iter: IndexedParallelIterator,
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,
<B as IntoParallelIterator>::Iter: IndexedParallelIterator,
<C as IntoParallelIterator>::Iter: IndexedParallelIterator,
<D as IntoParallelIterator>::Iter: IndexedParallelIterator,
<E as IntoParallelIterator>::Iter: IndexedParallelIterator,
<F as IntoParallelIterator>::Iter: IndexedParallelIterator,
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
sourceimpl<K, V> IntoParallelIterator for BTreeMap<K, V> where
K: Ord + Send,
V: Send,
impl<K, V> IntoParallelIterator for BTreeMap<K, V> where
K: Ord + Send,
V: Send,
type Item = <BTreeMap<K, V> as IntoIterator>::Item
type Iter = IntoIter<K, V>
fn into_par_iter(self) -> <BTreeMap<K, V> as IntoParallelIterator>::Iter
sourceimpl<T> IntoParallelIterator for Option<T> where
T: Send,
impl<T> IntoParallelIterator for Option<T> where
T: Send,
type Item = T
type Iter = IntoIter<T>
fn into_par_iter(self) -> <Option<T> as IntoParallelIterator>::Iter
sourceimpl<'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,
<B as IntoParallelRefMutIterator<'a>>::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,
<I as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
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,
<B as IntoParallelRefMutIterator<'a>>::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,
<I as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
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, <G as IntoParallelRefMutIterator<'a>>::Item, <H as IntoParallelRefMutIterator<'a>>::Item, <I 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, <G as IntoParallelRefMutIterator<'a>>::Iter, <H as IntoParallelRefMutIterator<'a>>::Iter, <I as IntoParallelRefMutIterator<'a>>::Iter)>
fn into_par_iter(
self
) -> <&'a mut (A, B, C, D, E, F, G, H, I) as IntoParallelIterator>::Iter
sourceimpl<T> IntoParallelIterator for BTreeSet<T> where
T: Ord + Send,
impl<T> IntoParallelIterator for BTreeSet<T> where
T: Ord + Send,
type Item = <BTreeSet<T> as IntoIterator>::Item
type Iter = IntoIter<T>
fn into_par_iter(self) -> <BTreeSet<T> as IntoParallelIterator>::Iter
sourceimpl<'data, T> IntoParallelIterator for &'data mut [T] where
T: 'data + Send,
impl<'data, T> IntoParallelIterator for &'data mut [T] where
T: 'data + Send,
type Item = &'data mut T
type Iter = IterMut<'data, T>
fn into_par_iter(self) -> <&'data mut [T] as IntoParallelIterator>::IterⓘNotable traits for &'_ [u8]impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]
sourceimpl<'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,
<B as IntoParallelRefMutIterator<'a>>::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,
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,
<B as IntoParallelRefMutIterator<'a>>::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,
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, <G 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, <G as IntoParallelRefMutIterator<'a>>::Iter)>
fn into_par_iter(
self
) -> <&'a mut (A, B, C, D, E, F, G) as IntoParallelIterator>::Iter
sourceimpl<T> IntoParallelIterator for LinkedList<T> where
T: Send,
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
sourceimpl<'a, A> IntoParallelIterator for &'a (A,) where
A: IntoParallelRefIterator<'a>,
<A as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
impl<'a, A> IntoParallelIterator for &'a (A,) where
A: IntoParallelRefIterator<'a>,
<A as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
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
sourceimpl<'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,
<B as IntoParallelRefMutIterator<'a>>::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,
<I as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
<J as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
<K as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
<L as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
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,
<B as IntoParallelRefMutIterator<'a>>::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,
<I as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
<J as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
<K as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
<L as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
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, <G as IntoParallelRefMutIterator<'a>>::Item, <H as IntoParallelRefMutIterator<'a>>::Item, <I as IntoParallelRefMutIterator<'a>>::Item, <J as IntoParallelRefMutIterator<'a>>::Item, <K as IntoParallelRefMutIterator<'a>>::Item, <L 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, <G as IntoParallelRefMutIterator<'a>>::Iter, <H as IntoParallelRefMutIterator<'a>>::Iter, <I as IntoParallelRefMutIterator<'a>>::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
sourceimpl<'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,
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,
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
sourceimpl<'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,
<B as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
<C as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
<D as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
<E as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
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,
<B as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
<C as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
<D as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
<E as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
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
sourceimpl<'a, K, V, S> IntoParallelIterator for &'a HashMap<K, V, S> where
K: Hash + Eq + Sync,
V: Sync,
S: BuildHasher,
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
sourceimpl<'a, A> IntoParallelIterator for &'a mut (A,) where
A: IntoParallelRefMutIterator<'a>,
<A as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
impl<'a, A> IntoParallelIterator for &'a mut (A,) where
A: IntoParallelRefMutIterator<'a>,
<A as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
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
sourceimpl<'a, T, S> IntoParallelIterator for &'a HashSet<T, S> where
T: Hash + Eq + Sync,
S: BuildHasher,
impl<'a, T, S> IntoParallelIterator for &'a HashSet<T, S> where
T: Hash + Eq + Sync,
S: BuildHasher,
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
sourceimpl<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,
<B as IntoParallelIterator>::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,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
<J as IntoParallelIterator>::Iter: IndexedParallelIterator,
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,
<B as IntoParallelIterator>::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,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
<J as IntoParallelIterator>::Iter: IndexedParallelIterator,
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, <I as IntoParallelIterator>::Item, <J 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, <H as IntoParallelIterator>::Iter, <I as IntoParallelIterator>::Iter, <J as IntoParallelIterator>::Iter)>
fn into_par_iter(
self
) -> <(A, B, C, D, E, F, G, H, I, J) as IntoParallelIterator>::Iter
sourceimpl<'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,
<B as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
<C as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
<D as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
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,
<B as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
<C as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
<D as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
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
sourceimpl<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,
<B as IntoParallelIterator>::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,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
<J as IntoParallelIterator>::Iter: IndexedParallelIterator,
<K as IntoParallelIterator>::Iter: IndexedParallelIterator,
<L as IntoParallelIterator>::Iter: IndexedParallelIterator,
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,
<B as IntoParallelIterator>::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,
<I as IntoParallelIterator>::Iter: IndexedParallelIterator,
<J as IntoParallelIterator>::Iter: IndexedParallelIterator,
<K as IntoParallelIterator>::Iter: IndexedParallelIterator,
<L as IntoParallelIterator>::Iter: IndexedParallelIterator,
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, <I as IntoParallelIterator>::Item, <J as IntoParallelIterator>::Item, <K as IntoParallelIterator>::Item, <L 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, <H as IntoParallelIterator>::Iter, <I as IntoParallelIterator>::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
sourceimpl<T, S> IntoParallelIterator for HashSet<T, S> where
T: Hash + Eq + Send,
S: BuildHasher,
impl<T, S> IntoParallelIterator for HashSet<T, S> where
T: Hash + Eq + Send,
S: BuildHasher,
type Item = <HashSet<T, S> as IntoIterator>::Item
type Iter = IntoIter<T>
fn into_par_iter(self) -> <HashSet<T, S> as IntoParallelIterator>::Iter
sourceimpl<'a, T> IntoParallelIterator for &'a mut LinkedList<T> where
T: Send,
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
sourceimpl<'a, T> IntoParallelIterator for &'a mut VecDeque<T, Global> where
T: Send,
impl<'a, T> IntoParallelIterator for &'a mut VecDeque<T, Global> where
T: Send,
type Item = &'a mut T
type Iter = IterMut<'a, T>
fn into_par_iter(
self
) -> <&'a mut VecDeque<T, Global> as IntoParallelIterator>::Iter
sourceimpl<'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,
<B as IntoParallelRefIterator<'a>>::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,
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,
<B as IntoParallelRefIterator<'a>>::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,
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, <G as IntoParallelRefIterator<'a>>::Item, <H 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, <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
sourceimpl<'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,
<B as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
<C as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
<D as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
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,
<B as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
<C as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
<D as IntoParallelRefMutIterator<'a>>::Iter: IndexedParallelIterator,
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
sourceimpl<'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,
<B as IntoParallelRefIterator<'a>>::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,
<I as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
<J as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
<K as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
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,
<B as IntoParallelRefIterator<'a>>::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,
<I as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
<J as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
<K as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
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, <G as IntoParallelRefIterator<'a>>::Item, <H as IntoParallelRefIterator<'a>>::Item, <I as IntoParallelRefIterator<'a>>::Item, <J as IntoParallelRefIterator<'a>>::Item, <K 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, <G as IntoParallelRefIterator<'a>>::Iter, <H as IntoParallelRefIterator<'a>>::Iter, <I as IntoParallelRefIterator<'a>>::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
sourceimpl<'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,
<B as IntoParallelRefIterator<'a>>::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,
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,
<B as IntoParallelRefIterator<'a>>::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,
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, <G 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, <G as IntoParallelRefIterator<'a>>::Iter)>
fn into_par_iter(
self
) -> <&'a (A, B, C, D, E, F, G) as IntoParallelIterator>::Iter
sourceimpl<'a, K, V> IntoParallelIterator for &'a BTreeMap<K, V> where
K: Ord + Sync,
V: Sync,
impl<'a, K, V> IntoParallelIterator for &'a BTreeMap<K, V> where
K: Ord + Sync,
V: Sync,
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
sourceimpl<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,
<B as IntoParallelIterator>::Iter: IndexedParallelIterator,
<C as IntoParallelIterator>::Iter: IndexedParallelIterator,
<D as IntoParallelIterator>::Iter: IndexedParallelIterator,
<E as IntoParallelIterator>::Iter: IndexedParallelIterator,
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,
<B as IntoParallelIterator>::Iter: IndexedParallelIterator,
<C as IntoParallelIterator>::Iter: IndexedParallelIterator,
<D as IntoParallelIterator>::Iter: IndexedParallelIterator,
<E as IntoParallelIterator>::Iter: IndexedParallelIterator,
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
sourceimpl<K, V, S> IntoParallelIterator for HashMap<K, V, S> where
K: Hash + Eq + Send,
V: Send,
S: BuildHasher,
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
sourceimpl<'a, T, E> IntoParallelIterator for &'a Result<T, E> where
T: Sync,
impl<'a, T, E> IntoParallelIterator for &'a Result<T, E> where
T: Sync,
type Item = &'a T
type Iter = Iter<'a, T>
fn into_par_iter(self) -> <&'a Result<T, E> as IntoParallelIterator>::Iter
sourceimpl<'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,
<B as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
<C as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
<D as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
<E as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
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,
<B as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
<C as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
<D as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
<E as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
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
sourceimpl<'a, T, E> IntoParallelIterator for &'a mut Result<T, E> where
T: Send,
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
sourceimpl<'data, T> IntoParallelIterator for &'data Vec<T, Global> where
T: 'data + Sync,
impl<'data, T> IntoParallelIterator for &'data Vec<T, Global> where
T: 'data + Sync,
sourceimpl<A, B, C> IntoParallelIterator for (A, B, C) where
A: IntoParallelIterator,
B: IntoParallelIterator,
C: IntoParallelIterator,
<A as IntoParallelIterator>::Iter: IndexedParallelIterator,
<B as IntoParallelIterator>::Iter: IndexedParallelIterator,
<C as IntoParallelIterator>::Iter: IndexedParallelIterator,
impl<A, B, C> IntoParallelIterator for (A, B, C) where
A: IntoParallelIterator,
B: IntoParallelIterator,
C: IntoParallelIterator,
<A as IntoParallelIterator>::Iter: IndexedParallelIterator,
<B as IntoParallelIterator>::Iter: IndexedParallelIterator,
<C as IntoParallelIterator>::Iter: IndexedParallelIterator,
type Item = (<A as IntoParallelIterator>::Item, <B as IntoParallelIterator>::Item, <C as IntoParallelIterator>::Item)
type Iter = MultiZip<(<A as IntoParallelIterator>::Iter, <B as IntoParallelIterator>::Iter, <C as IntoParallelIterator>::Iter)>
fn into_par_iter(self) -> <(A, B, C) as IntoParallelIterator>::Iter
sourceimpl<'a, T> IntoParallelIterator for &'a VecDeque<T, Global> where
T: Sync,
impl<'a, T> IntoParallelIterator for &'a VecDeque<T, Global> where
T: Sync,
type Item = &'a T
type Iter = Iter<'a, T>
fn into_par_iter(
self
) -> <&'a VecDeque<T, Global> as IntoParallelIterator>::Iter
sourceimpl<'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,
<B as IntoParallelRefIterator<'a>>::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,
<I as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
<J as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
<K as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
<L as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
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,
<B as IntoParallelRefIterator<'a>>::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,
<I as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
<J as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
<K as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
<L as IntoParallelRefIterator<'a>>::Iter: IndexedParallelIterator,
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, <G as IntoParallelRefIterator<'a>>::Item, <H as IntoParallelRefIterator<'a>>::Item, <I as IntoParallelRefIterator<'a>>::Item, <J as IntoParallelRefIterator<'a>>::Item, <K as IntoParallelRefIterator<'a>>::Item, <L 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, <G as IntoParallelRefIterator<'a>>::Iter, <H as IntoParallelRefIterator<'a>>::Iter, <I as IntoParallelRefIterator<'a>>::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
sourceimpl<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,
<B as IntoParallelIterator>::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,
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,
<B as IntoParallelIterator>::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,
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
sourceimpl<A> IntoParallelIterator for (A,) where
A: IntoParallelIterator,
<A as IntoParallelIterator>::Iter: IndexedParallelIterator,
impl<A> IntoParallelIterator for (A,) where
A: IntoParallelIterator,
<A as IntoParallelIterator>::Iter: IndexedParallelIterator,
type Item = (<A as IntoParallelIterator>::Item,)
type Iter = MultiZip<(<A as IntoParallelIterator>::Iter,)>
fn into_par_iter(self) -> <(A,) as IntoParallelIterator>::Iter
sourceimpl<'data, T, const N: usize> IntoParallelIterator for &'data mut [T; N] where
T: 'data + Send,
impl<'data, T, const N: usize> IntoParallelIterator for &'data mut [T; N] where
T: 'data + Send,
This implementation requires const generics, stabilized in Rust 1.51.