orx_parallel

Trait ParallelizableCollectionMut

Source 
pub trait ParallelizableCollectionMut: ConcurrentCollectionMut + ParallelizableCollection {
    // Provided method
    fn par_mut(&mut self) -> impl ParIter<DefaultRunner, Item = &mut Self::Item> { ... }
}
Expand description

A type implementing ParallelizableCollectionMut is a collection owning the elements such that

  • if the elements are of type T,
  • non-consuming par method can be called multiple times to create parallel iterators; i.e., ParIter, yielding references to the elements &T; and
  • non-consuming par_mut method can be called multiple times to create parallel iterators yielding mutable references to the elements &mut T; and
  • consuming into_par method can be called once to create a parallel iterator yielding owned elements T.

This trait can be considered as the concurrent counterpart of the CollectionMut trait.

Note that every ConcurrentCollectionMut type automatically implements ParallelizableCollectionMut.

§Examples

use orx_parallel::*;

// Vec<T>: ParallelizableCollectionMut<Item = T>
let mut vec = vec![1, 2, 3, 4];

// non-consuming iteration over references
assert_eq!(vec.par().sum(), 10);
assert_eq!(vec.par().min(), Some(&1));
assert_eq!(vec.par().max(), Some(&4));

// non-consuming mutable iteration
vec.par_mut().filter(|x| **x >= 3).for_each(|x| *x += 10);
assert_eq!(&vec, &[1, 2, 13, 14]);

// consuming iteration over owned values
assert_eq!(vec.into_par().max(), Some(14));

Provided Methods§

Source

fn par_mut(&mut self) -> impl ParIter<DefaultRunner, Item = &mut Self::Item>

Creates a parallel iterator over mutable references of the collection’s elements.

§Examples
use orx_parallel::*;

// Vec<T>: ParallelizableCollectionMut<Item = T>
let mut vec = vec![1, 2, 3, 4];

vec.par_mut().filter(|x| **x >= 3).for_each(|x| *x += 10);

assert_eq!(&vec, &[1, 2, 13, 14]);

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors§