Trait ParallelSliceMut 

pub trait ParallelSliceMut<T: Send> {
    // Required methods
    fn par_sort(&mut self)
       where T: Ord;
    fn par_sort_by<F>(&mut self, compare: F)
       where F: Fn(&T, &T) -> Ordering + Sync + Send;
    fn par_sort_by_key<K, F>(&mut self, f: F)
       where F: Fn(&T) -> K + Sync + Send,
             K: Ord + Send;
    fn par_sort_unstable(&mut self)
       where T: Ord;
    fn par_sort_unstable_by<F>(&mut self, compare: F)
       where F: Fn(&T, &T) -> Ordering + Sync + Send;
    fn par_sort_unstable_by_key<K, F>(&mut self, f: F)
       where F: Fn(&T) -> K + Sync + Send,
             K: Ord + Send;
}

Extension trait for parallel slice sorting.

Required Methods

fn par_sort(&mut self)

where T: Ord,

Sorts the slice in parallel (stable).

fn par_sort_by<F>(&mut self, compare: F)

where F: Fn(&T, &T) -> Ordering + Sync + Send,

Sorts the slice in parallel with a comparator (stable).

fn par_sort_by_key<K, F>(&mut self, f: F)

where F: Fn(&T) -> K + Sync + Send, K: Ord + Send,

Sorts the slice in parallel with a key extraction function (stable).

fn par_sort_unstable(&mut self)

where T: Ord,

Sorts the slice in parallel (unstable).

fn par_sort_unstable_by<F>(&mut self, compare: F)

where F: Fn(&T, &T) -> Ordering + Sync + Send,

Sorts the slice in parallel with a comparator (unstable).

fn par_sort_unstable_by_key<K, F>(&mut self, f: F)

where F: Fn(&T) -> K + Sync + Send, K: Ord + Send,

Sorts the slice in parallel with a key extraction function (unstable).

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<T: Send> ParallelSliceMut<T> for [T]

fn par_sort(&mut self)

where T: Ord,

fn par_sort_by<F>(&mut self, compare: F)

where F: Fn(&T, &T) -> Ordering + Sync + Send,

fn par_sort_by_key<K, F>(&mut self, f: F)

where F: Fn(&T) -> K + Sync + Send, K: Ord + Send,

fn par_sort_unstable(&mut self)

where T: Ord,

fn par_sort_unstable_by<F>(&mut self, compare: F)

where F: Fn(&T, &T) -> Ordering + Sync + Send,

fn par_sort_unstable_by_key<K, F>(&mut self, f: F)

where F: Fn(&T) -> K + Sync + Send, K: Ord + Send,

Implementors