Struct rayon::par_iter::zip::ZipIter

pub struct ZipIter<A: IndexedParallelIterator, B: IndexedParallelIterator> {
    // some fields omitted
}

Methods

impl<A: IndexedParallelIterator, B: IndexedParallelIterator> ZipIter<A, B>

fn new(a: A, b: B) -> ZipIter<A, B>

Trait Implementations

impl<A, B> ParallelIterator for ZipIter<A, B> where A: IndexedParallelIterator, B: IndexedParallelIterator

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

fn drive_unindexed<C>(self, consumer: C) -> C::Result where C: UnindexedConsumer<Self::Item>

fn weight(self, scale: f64) -> Weight<Self>

fn weight_max(self) -> Weight<Self>

fn for_each<OP>(self, op: OP) where OP: Fn(Self::Item) + Sync

fn map<MAP_OP, R>(self, map_op: MAP_OP) -> Map<Self, MAP_OP> where MAP_OP: Fn(Self::Item) -> R

fn filter<FILTER_OP>(self, filter_op: FILTER_OP) -> Filter<Self, FILTER_OP> where FILTER_OP: Fn(&Self::Item) -> bool

fn filter_map<FILTER_OP, R>(self, filter_op: FILTER_OP) -> FilterMap<Self, FILTER_OP> where FILTER_OP: Fn(Self::Item) -> Option<R>

fn flat_map<MAP_OP, PI>(self, map_op: MAP_OP) -> FlatMap<Self, MAP_OP> where MAP_OP: Fn(Self::Item) -> PI, PI: ParallelIterator

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync

fn reduce_with_identity<OP>(self, identity: Self::Item, op: OP) -> Self::Item where OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync, Self::Item: Clone + Sync

fn sum(self) -> Self::Item where SumOp: ReduceOp<Self::Item>

fn mul(self) -> Self::Item where MulOp: ReduceOp<Self::Item>

fn min(self) -> Self::Item where MinOp: ReduceOp<Self::Item>

fn max(self) -> Self::Item where MaxOp: ReduceOp<Self::Item>

fn reduce<REDUCE_OP>(self, reduce_op: &REDUCE_OP) -> Self::Item where REDUCE_OP: ReduceOp<Self::Item>

impl<A, B> BoundedParallelIterator for ZipIter<A, B> where A: IndexedParallelIterator, B: IndexedParallelIterator

fn upper_bound(&mut self) -> usize

fn drive<C>(self, consumer: C) -> C::Result where C: Consumer<Self::Item>

impl<A, B> ExactParallelIterator for ZipIter<A, B> where A: IndexedParallelIterator, B: IndexedParallelIterator

fn len(&mut self) -> usize

fn collect_into(self, target: &mut Vec<Self::Item>)

impl<A, B> IndexedParallelIterator for ZipIter<A, B> where A: IndexedParallelIterator, B: IndexedParallelIterator

fn with_producer<CB>(self, callback: CB) -> CB::Output where CB: ProducerCallback<Self::Item>

fn zip<ZIP_OP>(self, zip_op: ZIP_OP) -> ZipIter<Self, ZIP_OP::Iter> where ZIP_OP: IntoParallelIterator, ZIP_OP::Iter: IndexedParallelIterator

fn enumerate(self) -> Enumerate<Self>