Struct rayon::iter::TryFoldWith

[+] Show declaration

[+] Expand attributes
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct TryFoldWith<I, U: Try, F> { /* fields omitted */ }

[−] Expand description

TryFoldWith is an iterator that applies a function over an iterator producing a single value. This struct is created by the try_fold_with() method on ParallelIterator

Trait Implementations

impl<U, I, F> ParallelIterator for TryFoldWith<I, U, F> where     I: ParallelIterator,     F: Fn(U::Ok, I::Item) -> U + Sync + Send,     U: Try + Send,     U::Ok: Clone + Send,

[+]

type Item = U

The type of item that this parallel iterator produces. For example, if you use the [for_each] method, this is the type of item that your closure will be invoked with.

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

[−]

Internal method used to define the behavior of this parallel iterator. You should not need to call this directly.

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

[−]

Executes OP on each item produced by the iterator, in parallel.

fn for_each_with<OP, T>(self, init: T, op: OP) where     OP: Fn(&mut T, Self::Item) + Sync + Send,     T: Send + Clone,

[−]

Executes OP on the given init value with each item produced by the iterator, in parallel.

fn try_for_each<OP, R>(self, op: OP) -> R where     OP: Fn(Self::Item) -> R + Sync + Send,     R: Try<Ok = ()> + Send,

[−]

Executes a fallible OP on each item produced by the iterator, in parallel.

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where     OP: Fn(&mut T, Self::Item) -> R + Sync + Send,     T: Send + Clone,     R: Try<Ok = ()> + Send,

[−]

Executes a fallible OP on the given init value with each item produced by the iterator, in parallel.

fn count(self) -> usize

[−]

Counts the number of items in this parallel iterator.

fn map<F, R>(self, map_op: F) -> Map<Self, F> where     F: Fn(Self::Item) -> R + Sync + Send,     R: Send,

[−]

Applies map_op to each item of this iterator, producing a new iterator with the results.

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where     F: Fn(&mut T, Self::Item) -> R + Sync + Send,     T: Send + Clone,     R: Send,

[−]

Applies map_op to the given init value with each item of this iterator, producing a new iterator with the results.

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

[−]

Creates an iterator which clones all of its elements. This may be useful when you have an iterator over &T, but you need T.

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where     OP: Fn(&Self::Item) + Sync + Send,

[−]

Applies inspect_op to a reference to each item of this iterator, producing a new iterator passing through the original items. This is often useful for debugging to see what's happening in iterator stages.

fn update<F>(self, update_op: F) -> Update<Self, F> where     F: Fn(&mut Self::Item) + Sync + Send,

[−]

Mutates each item of this iterator before yielding it.

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

[−]

Applies filter_op to each item of this iterator, producing a new iterator with only the items that gave true results.

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

[−]

Applies filter_op to each item of this iterator to get an Option, producing a new iterator with only the items from Some results.

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

[−]

Applies map_op to each item of this iterator to get nested iterators, producing a new iterator that flattens these back into one.

fn flatten(self) -> Flatten<Self> where     Self::Item: IntoParallelIterator,

[−]

An adaptor that flattens iterable Items into one large iterator

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where     OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,     ID: Fn() -> Self::Item + Sync + Send,

[−]

Reduces the items in the iterator into one item using op. The argument identity should be a closure that can produce "identity" value which may be inserted into the sequence as needed to create opportunities for parallel execution. So, for example, if you are doing a summation, then identity() ought to produce something that represents the zero for your type (but consider just calling sum() in that case).

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

[−]

Reduces the items in the iterator into one item using op. If the iterator is empty, None is returned; otherwise, Some is returned.

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where     OP: Fn(T, T) -> Self::Item + Sync + Send,     ID: Fn() -> T + Sync + Send,     Self::Item: Try<Ok = T>,

[−]

Reduces the items in the iterator into one item using a fallible op. The identity argument is used the same way as in [reduce()].

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where     OP: Fn(T, T) -> Self::Item + Sync + Send,     Self::Item: Try<Ok = T>,

[−]

Reduces the items in the iterator into one item using a fallible op.

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where     F: Fn(T, Self::Item) -> T + Sync + Send,     ID: Fn() -> T + Sync + Send,     T: Send,

[−]

Parallel fold is similar to sequential fold except that the sequence of items may be subdivided before it is folded. Consider a list of numbers like 22 3 77 89 46. If you used sequential fold to add them (fold(0, |a,b| a+b), you would wind up first adding 0 + 22, then 22 + 3, then 25 + 77, and so forth. The parallel fold works similarly except that it first breaks up your list into sublists, and hence instead of yielding up a single sum at the end, it yields up multiple sums. The number of results is nondeterministic, as is the point where the breaks occur.

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where     F: Fn(T, Self::Item) -> T + Sync + Send,     T: Send + Clone,

[−]

Applies fold_op to the given init value with each item of this iterator, finally producing the value for further use.

fn try_fold<T, R, ID, F>(     self,     identity: ID,     fold_op: F ) -> TryFold<Self, R, ID, F> where     F: Fn(T, Self::Item) -> R + Sync + Send,     ID: Fn() -> T + Sync + Send,     R: Try<Ok = T> + Send,

[−]

Perform a fallible parallel fold.

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where     F: Fn(T, Self::Item) -> R + Sync + Send,     R: Try<Ok = T> + Send,     T: Clone + Send,

[−]

Perform a fallible parallel fold with a cloneable init value.

fn sum<S>(self) -> S where     S: Send + Sum<Self::Item> + Sum<S>,

[−]

Sums up the items in the iterator.

fn product<P>(self) -> P where     P: Send + Product<Self::Item> + Product<P>,

[−]

Multiplies all the items in the iterator.

fn min(self) -> Option<Self::Item> where     Self::Item: Ord,

[−]

Computes the minimum of all the items in the iterator. If the iterator is empty, None is returned; otherwise, Some(min) is returned.

fn min_by<F>(self, f: F) -> Option<Self::Item> where     F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,

[−]

Computes the minimum of all the items in the iterator with respect to the given comparison function. If the iterator is empty, None is returned; otherwise, Some(min) is returned.

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where     K: Ord + Send,     F: Sync + Send + Fn(&Self::Item) -> K,

[−]

Computes the item that yields the minimum value for the given function. If the iterator is empty, None is returned; otherwise, Some(item) is returned.

fn max(self) -> Option<Self::Item> where     Self::Item: Ord,

[−]

Computes the maximum of all the items in the iterator. If the iterator is empty, None is returned; otherwise, Some(max) is returned.

fn max_by<F>(self, f: F) -> Option<Self::Item> where     F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,

[−]

Computes the maximum of all the items in the iterator with respect to the given comparison function. If the iterator is empty, None is returned; otherwise, Some(min) is returned.

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where     K: Ord + Send,     F: Sync + Send + Fn(&Self::Item) -> K,

[−]

Computes the item that yields the maximum value for the given function. If the iterator is empty, None is returned; otherwise, Some(item) is returned.

fn chain<C>(self, chain: C) -> Chain<Self, C::Iter> where     C: IntoParallelIterator<Item = Self::Item>,

[−]

Takes two iterators and creates a new iterator over both.

fn find_any<P>(self, predicate: P) -> Option<Self::Item> where     P: Fn(&Self::Item) -> bool + Sync + Send,

[−]

Searches for some item in the parallel iterator that matches the given predicate and returns it. This operation is similar to [find on sequential iterators][find] but the item returned may not be the first one in the parallel sequence which matches, since we search the entire sequence in parallel.

fn find_first<P>(self, predicate: P) -> Option<Self::Item> where     P: Fn(&Self::Item) -> bool + Sync + Send,

[−]

Searches for the sequentially first item in the parallel iterator that matches the given predicate and returns it.

fn find_last<P>(self, predicate: P) -> Option<Self::Item> where     P: Fn(&Self::Item) -> bool + Sync + Send,

[−]

Searches for the sequentially last item in the parallel iterator that matches the given predicate and returns it.

fn any<P>(self, predicate: P) -> bool where     P: Fn(Self::Item) -> bool + Sync + Send,

[−]

Searches for some item in the parallel iterator that matches the given predicate, and if so returns true. Once a match is found, we'll attempt to stop process the rest of the items. Proving that there's no match, returning false, does require visiting every item.

fn all<P>(self, predicate: P) -> bool where     P: Fn(Self::Item) -> bool + Sync + Send,

[−]

Tests that every item in the parallel iterator matches the given predicate, and if so returns true. If a counter-example is found, we'll attempt to stop processing more items, then return false.

fn while_some<T>(self) -> WhileSome<Self> where     Self: ParallelIterator<Item = Option<T>>,     T: Send,

[−]

Creates an iterator over the Some items of this iterator, halting as soon as any None is found.

fn collect<C>(self) -> C where     C: FromParallelIterator<Self::Item>,

[−]

Create a fresh collection containing all the element produced by this parallel iterator.

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where     Self: ParallelIterator<Item = (A, B)>,     FromA: Default + Send + ParallelExtend<A>,     FromB: Default + Send + ParallelExtend<B>,     A: Send,     B: Send,

[−]

Unzips the items of a parallel iterator into a pair of arbitrary ParallelExtend containers.

fn partition<A, B, P>(self, predicate: P) -> (A, B) where     A: Default + Send + ParallelExtend<Self::Item>,     B: Default + Send + ParallelExtend<Self::Item>,     P: Fn(&Self::Item) -> bool + Sync + Send,

[−]

Partitions the items of a parallel iterator into a pair of arbitrary ParallelExtend containers. Items for which the predicate returns true go into the first container, and the rest go into the second.

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where     A: Default + Send + ParallelExtend<L>,     B: Default + Send + ParallelExtend<R>,     P: Fn(Self::Item) -> Either<L, R> + Sync + Send,     L: Send,     R: Send,

[−]

Partitions and maps the items of a parallel iterator into a pair of arbitrary ParallelExtend containers. Either::Left items go into the first container, and Either::Right items go into the second.

fn intersperse(self, element: Self::Item) -> Intersperse<Self> where     Self::Item: Clone,

[−]

Intersperses clones of an element between items of this iterator.

fn opt_len(&self) -> Option<usize>

[−]

Internal method used to define the behavior of this parallel iterator. You should not need to call this directly.

impl<I: Clone, U: Clone + Try, F: Clone> Clone for TryFoldWith<I, U, F> where     U::Ok: Clone,

[+]

fn clone(&self) -> TryFoldWith<I, U, F>

[−]

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

[−]

Performs copy-assignment from source.

impl<I: ParallelIterator + Debug, U: Try, F> Debug for TryFoldWith<I, U, F> where     U::Ok: Debug,

[+]

fn fmt(&self, f: &mut Formatter) -> Result

[−]

Formats the value using the given formatter.