| Consumer | A consumer is effectively a generalized "fold" operation,
and in fact each consumer will eventually be converted into a
Folder. What makes a consumer special is that, like a
Producer, it can be split into multiple consumers using
the split_off_left method. When a consumer is split, it produces two
consumers, as well as a reducer. The two consumers can be fed
items independently, and when they are done the reducer is used to
combine their two results into one. See the README for further
details.
|
| Driver | |
| Executor | |
| Folder | The Folder trait encapsulates the standard fold
operation. It can be fed many items using the consume
method. At the end, once all items have been consumed, it can then
be converted (using complete) into a final value.
|
| FromParallelIterator | FromParallelIterator implements the creation of a collection
from a ParallelIterator. By implementing
FromParallelIterator for a given type, you define how it will be
created from an iterator.
|
| IndexedParallelIterator | An iterator that supports "random access" to its data, meaning
that you can split it at arbitrary indices and draw data from
those points.
|
| IndexedProducer | A Producer is effectively a "splittable IntoIterator". That
is, a producer is a value which can be converted into an iterator
at any time: at that point, it simply produces items on demand,
like any iterator. But what makes a Producer special is that,
before we convert to an iterator, we can also split it at a
particular point using the split_at method. This will yield up
two producers, one producing the items before that point, and one
producing the items after that point (these two producers can then
independently be split further, or be converted into iterators).
In Rayon, this splitting is used to divide between threads.
See the plumbing README for further details.
|
| IndexedProducerCallback | The IndexedProducerCallback trait is a kind of generic closure,
analogous to FnOnce. See the corresponding section in
the plumbing README for more details.
|
| IntoParallelIterator | IntoParallelIterator implements the conversion to a ParallelIterator.
|
| IntoParallelRefIterator | IntoParallelRefIterator implements the conversion to a
ParallelIterator, providing shared references to the data.
|
| IntoParallelRefMutIterator | IntoParallelRefMutIterator implements the conversion to a
ParallelIterator, providing mutable references to the data.
|
| ParallelDrainFull | ParallelDrainFull creates a parallel iterator that moves all items
from a collection while retaining the original capacity.
|
| ParallelDrainRange | ParallelDrainRange creates a parallel iterator that moves a range of items
from a collection while retaining the original capacity.
|
| ParallelExtend | ParallelExtend extends an existing collection with items from a ParallelIterator.
|
| ParallelIterator | Parallel version of the standard iterator trait.
|
| Producer | A variant on Producer which does not know its exact length or
cannot represent it in a usize. These producers act like
ordinary producers except that they cannot be told to split at a
particular point. Instead, you just ask them to split 'somewhere'.
|
| ProducerCallback | The ProducerCallback trait is a kind of generic closure,
analogous to FnOnce. See the corresponding section in
the plumbing README for more details.
|
| Reducer | The reducer is the final step of a Consumer -- after a consumer
has been split into two parts, and each of those parts has been
fully processed, we are left with two results. The reducer is then
used to combine those two results into one. See the plumbing
README for further details.
|
| WithIndexedProducer | |
| WithProducer | |
| WithSetup | |