Name Description Size
collections 8
compile_fail 7
delegate.rs Macros for delegating newtype iterators to inner types. 2080
iter 52
lib.rs Data-parallelism library that makes it easy to convert sequential computations into parallel Rayon is lightweight and convenient for introducing parallelism into existing code. It guarantees data-race free executions and takes advantage of parallelism when sensible, based on work-load at runtime. # How to use Rayon There are two ways to use Rayon: - **High-level parallel constructs** are the simplest way to use Rayon and also typically the most efficient. - [Parallel iterators][iter module] make it easy to convert a sequential iterator to execute in parallel. - The [`ParallelIterator`] trait defines general methods for all parallel iterators. - The [`IndexedParallelIterator`] trait adds methods for iterators that support random access. - The [`par_sort`] method sorts `&mut [T]` slices (or vectors) in parallel. - [`par_extend`] can be used to efficiently grow collections with items produced by a parallel iterator. - **Custom tasks** let you divide your work into parallel tasks yourself. - [`join`] is used to subdivide a task into two pieces. - [`scope`] creates a scope within which you can create any number of parallel tasks. - [`ThreadPoolBuilder`] can be used to create your own thread pools or customize the global one. [iter module]: iter/index.html [`join`]: fn.join.html [`scope`]: fn.scope.html [`par_sort`]: slice/trait.ParallelSliceMut.html#method.par_sort [`par_extend`]: iter/trait.ParallelExtend.html#tymethod.par_extend [`ThreadPoolBuilder`]: struct.ThreadPoolBuilder.html # Basic usage and the Rayon prelude First, you will need to add `rayon` to your `Cargo.toml`. Next, to use parallel iterators or the other high-level methods, you need to import several traits. Those traits are bundled into the module [`rayon::prelude`]. It is recommended that you import all of these traits at once by adding `use rayon::prelude::*` at the top of each module that uses Rayon methods. These traits give you access to the `par_iter` method which provides parallel implementations of many iterative functions such as [`map`], [`for_each`], [`filter`], [`fold`], and [more]. [`rayon::prelude`]: prelude/index.html [`map`]: iter/trait.ParallelIterator.html#method.map [`for_each`]: iter/trait.ParallelIterator.html#method.for_each [`filter`]: iter/trait.ParallelIterator.html#method.filter [`fold`]: iter/trait.ParallelIterator.html#method.fold [more]: iter/trait.ParallelIterator.html#provided-methods [`ParallelIterator`]: iter/trait.ParallelIterator.html [`IndexedParallelIterator`]: iter/trait.IndexedParallelIterator.html # Crate Layout Rayon extends many of the types found in the standard library with parallel iterator implementations. The modules in the `rayon` crate mirror [`std`] itself: so, e.g., the `option` module in Rayon contains parallel iterators for the `Option` type, which is found in [the `option` module of `std`]. Similarly, the `collections` module in Rayon offers parallel iterator types for [the `collections` from `std`]. You will rarely need to access these submodules unless you need to name iterator types explicitly. [the `option` module of `std`]: https://doc.rust-lang.org/std/option/index.html [the `collections` from `std`]: https://doc.rust-lang.org/std/collections/index.html [`std`]: https://doc.rust-lang.org/std/ # Other questions? See [the Rayon FAQ][faq]. [faq]: https://github.com/rayon-rs/rayon/blob/master/FAQ.md 4612
math.rs 1576
option.rs Parallel iterator types for [options][std::option] You will rarely need to interact with this module directly unless you need to name one of the iterator types. [std::option]: https://doc.rust-lang.org/stable/std/option/ 5438
par_either.rs 1904
prelude.rs The rayon prelude imports the various `ParallelIterator` traits. The intention is that one can include `use rayon::prelude::*` and have easy access to the various traits and methods you will need. 744
private.rs The public parts of this private module are used to create traits that cannot be implemented outside of our own crate. This way we can feel free to extend those traits without worrying about it being a breaking change for other implementations. 886
range.rs Parallel iterator types for [ranges][std::range], the type for values created by `a..b` expressions You will rarely need to interact with this module directly unless you have need to name one of the iterator types. ``` use rayon::prelude::*; let r = (0..100u64).into_par_iter() .sum(); // compare result with sequential calculation assert_eq!((0..100).sum::<u64>(), r); ``` [std::range]: https://doc.rust-lang.org/core/ops/struct.Range.html 10737
range_inclusive.rs Parallel iterator types for [inclusive ranges][std::range], the type for values created by `a..=b` expressions You will rarely need to interact with this module directly unless you have need to name one of the iterator types. ``` use rayon::prelude::*; let r = (0..=100u64).into_par_iter() .sum(); // compare result with sequential calculation assert_eq!((0..=100).sum::<u64>(), r); ``` [std::range]: https://doc.rust-lang.org/core/ops/struct.RangeInclusive.html 8590
result.rs Parallel iterator types for [results][std::result] You will rarely need to interact with this module directly unless you need to name one of the iterator types. [std::result]: https://doc.rust-lang.org/stable/std/result/ 3409
slice 4
split_producer.rs Common splitter for strings and slices This module is private, so these items are effectively `pub(super)` 4112
str.rs Parallel iterator types for [strings][std::str] You will rarely need to interact with this module directly unless you need to name one of the iterator types. Note: [`ParallelString::par_split()`] and [`par_split_terminator()`] reference a `Pattern` trait which is not visible outside this crate. This trait is intentionally kept private, for use only by Rayon itself. It is implemented for `char` and any `F: Fn(char) -> bool + Sync + Send`. [`ParallelString::par_split()`]: trait.ParallelString.html#method.par_split [`par_split_terminator()`]: trait.ParallelString.html#method.par_split_terminator [std::str]: https://doc.rust-lang.org/stable/std/str/ 24630
string.rs This module contains the parallel iterator types for owned strings (`String`). You will rarely need to interact with it directly unless you have need to name one of the iterator types. 1266
vec.rs Parallel iterator types for [vectors][std::vec] (`Vec<T>`) You will rarely need to interact with this module directly unless you need to name one of the iterator types. [std::vec]: https://doc.rust-lang.org/stable/std/vec/ 6942