Struct rayon::par_iter::weight::Weight

pub struct Weight<M> {
    // some fields omitted
}

Methods

impl<M> Weight<M>

fn new(base: M, weight: f64) -> Weight<M>

Trait Implementations

impl<M> ParallelIterator for Weight<M> where M: ParallelIterator

type Item = M::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<M: BoundedParallelIterator> BoundedParallelIterator for Weight<M>

fn upper_bound(&mut self) -> usize

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

impl<M: ExactParallelIterator> ExactParallelIterator for Weight<M>

fn len(&mut self) -> usize

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

impl<M: IndexedParallelIterator> IndexedParallelIterator for Weight<M>

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>