# [−][src]Trait rayon::iter::plumbing::Producer

    pub trait Producer: Send + Sized {
        type Item;
        type IntoIter: Iterator<Item = Self::Item> + DoubleEndedIterator + ExactSizeIterator;
        fn into_iter(self) -> Self::IntoIter;
        fn split_at(self, index: usize) -> (Self, Self);

        fn min_len(&self) -> usize { ... }
        fn max_len(&self) -> usize { ... }
        fn fold_with<F>(self, folder: F) -> F
        where
            F: Folder<Self::Item>,
        { ... }
    }

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.

Note that each producer will always produce a fixed number of items N. However, this number N is not queryable through the API; the consumer is expected to track it.

NB. You might expect `Producer` to extend the `IntoIterator` trait. However, rust-lang/rust#20671 prevents us from declaring the DoubleEndedIterator and ExactSizeIterator constraints on a required IntoIterator trait, so we inline IntoIterator here until that issue is fixed.

## Associated Types

### `type Item`

The type of item that will be produced by this producer once it is converted into an iterator.

### `type IntoIter: Iterator<Item = Self::Item> + DoubleEndedIterator + ExactSizeIterator`

The type of iterator we will become.

Loading content...

## Required methods

### `fn into_iter(self) -> Self::IntoIter`

Convert `self` into an iterator; at this point, no more parallel splits are possible.

### `fn split_at(self, index: usize) -> (Self, Self)`

Split into two producers; one produces items `0..index`, the other `index..N`. Index must be less than or equal to `N`.

Loading content...

## Provided methods

### `fn min_len(&self) -> usize`

The minimum number of items that we will process sequentially. Defaults to 1, which means that we will split all the way down to a single item. This can be raised higher using the `with_min_len` method, which will force us to create sequential tasks at a larger granularity. Note that Rayon automatically normally attempts to adjust the size of parallel splits to reduce overhead, so this should not be needed.

### `fn max_len(&self) -> usize`

The maximum number of items that we will process sequentially. Defaults to MAX, which means that we can choose not to split at all. This can be lowered using the `with_max_len` method, which will force us to create more parallel tasks. Note that Rayon automatically normally attempts to adjust the size of parallel splits to reduce overhead, so this should not be needed.

### `fn fold_with<F>(self, folder: F) -> F where
F: Folder<Self::Item>,`

Iterate the producer, feeding each element to `folder`, and stop when the folder is full (or all elements have been consumed).

The provided implementation is sufficient for most iterables.

Loading content...

## Implementors

Loading content...

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)