# [−][src]Trait rayon::slice::ParallelSlice

    pub trait ParallelSlice<T: Sync> {
        fn as_parallel_slice(&self) -> &[T];

        fn par_split<P>(&self, separator: P) -> Split<T, P>
        where
            P: Fn(&T) -> bool + Sync + Send,
        { ... }
        fn par_windows(&self, window_size: usize) -> Windows<T> { ... }
        fn par_chunks(&self, chunk_size: usize) -> Chunks<T> { ... }
    }

Parallel extensions for slices.

## Required methods

### `fn as_parallel_slice(&self) -> &[T]`

Returns a plain slice, which is used to implement the rest of the parallel methods.

Loading content...

## Provided methods

### `fn par_split<P>(&self, separator: P) -> Split<T, P> where
P: Fn(&T) -> bool + Sync + Send,`

Returns a parallel iterator over subslices separated by elements that match the separator.

# Examples

    use rayon::prelude::*;
    let smallest = [1, 2, 3, 0, 2, 4, 8, 0, 3, 6, 9]
        .par_split(|i| *i == 0)
        .map(|numbers| numbers.iter().min().unwrap())
        .min();
    assert_eq!(Some(&1), smallest);

### `fn par_windows(&self, window_size: usize) -> Windows<T>`

Returns a parallel iterator over all contiguous windows of length `window_size`. The windows overlap.

# Examples

    use rayon::prelude::*;
    let windows: Vec<_> = [1, 2, 3].par_windows(2).collect();
    assert_eq!(vec![[1, 2], [2, 3]], windows);

### `fn par_chunks(&self, chunk_size: usize) -> Chunks<T>`

Returns a parallel iterator over at most `chunk_size` elements of `self` at a time. The chunks do not overlap.

If the number of elements in the iterator is not divisible by `chunk_size`, the last chunk may be shorter than `chunk_size`. All other chunks will have that exact length.

# Examples

    use rayon::prelude::*;
    let chunks: Vec<_> = [1, 2, 3, 4, 5].par_chunks(2).collect();
    assert_eq!(chunks, vec![&[1, 2][..], &[3, 4], &[5]]);

Loading content...

## Implementations on Foreign Types

### `impl<T: Sync> ParallelSlice<T> for [T]`[src]

#### `fn as_parallel_slice(&self) -> &[T]`[src]

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`)