Struct rayon::par_iter::map::Map

pub struct Map<M, MAP_OP> {
    // some fields omitted
}

Methods

impl<M, MAP_OP> Map<M, MAP_OP>

fn new(base: M, map_op: MAP_OP) -> Map<M, MAP_OP>

Trait Implementations

impl<M, MAP_OP> ParallelIterator for Map<M, MAP_OP> where M: ParallelIterator, MAP_OP: MapOp<M::Item>

type Item = MAP_OP::Output

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, MapFn<MAP_OP>> where MAP_OP: Fn(Self::Item) -> R + Sync

fn cloned<'a, T>(self) -> Map<Self, MapCloned> where T: 'a + Clone, Self: ParallelIterator<Item=&'a T>

fn inspect<INSPECT_OP>(self, inspect_op: INSPECT_OP) -> Map<Self, MapInspect<INSPECT_OP>> where INSPECT_OP: Fn(&Self::Item) + Sync

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

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

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

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<M, MAP_OP> BoundedParallelIterator for Map<M, MAP_OP> where M: BoundedParallelIterator, MAP_OP: MapOp<M::Item>

fn upper_bound(&mut self) -> usize

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

impl<M, MAP_OP> ExactParallelIterator for Map<M, MAP_OP> where M: ExactParallelIterator, MAP_OP: MapOp<M::Item>

fn len(&mut self) -> usize

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

impl<M, MAP_OP> IndexedParallelIterator for Map<M, MAP_OP> where M: IndexedParallelIterator, MAP_OP: MapOp<M::Item>

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>