Trait ParallelExtend

pub trait ParallelExtend<T>
where
    T: Send,
{
    // Required method
    fn par_extend<I>(&mut self, par_iter: I)
       where I: IntoParallelIterator<Item = T>;
}

ParallelExtend extends an existing collection with items from a ParallelIterator.

Examples

Implementing ParallelExtend for your type:

use rayon::prelude::*;
use std::mem;

struct BlackHole {
    mass: usize,
}

impl<T: Send> ParallelExtend<T> for BlackHole {
    fn par_extend<I>(&mut self, par_iter: I)
        where I: IntoParallelIterator<Item = T>
    {
        let par_iter = par_iter.into_par_iter();
        self.mass += par_iter.count() * mem::size_of::<T>();
    }
}

let mut bh = BlackHole { mass: 0 };
bh.par_extend(0i32..1000);
assert_eq!(bh.mass, 4000);
bh.par_extend(0i64..10);
assert_eq!(bh.mass, 4080);

Required Methods

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = T>,

Extends an instance of the collection with the elements drawn from the parallel iterator par_iter.

Examples

use rayon::prelude::*;

let mut vec = vec![];
vec.par_extend(0..5);
vec.par_extend((0..5).into_par_iter().map(|i| i * i));
assert_eq!(vec, [0, 1, 2, 3, 4, 0, 1, 4, 9, 16]);

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.

Implementations on Foreign Types

impl ParallelExtend<char> for String

Extends a string with characters from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = char>,

impl ParallelExtend<()> for ()

Collapses all unit items from a parallel iterator into one.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = ()>,

impl ParallelExtend<Box<str>> for String

Extends a string with boxed strings from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = Box<str>>,

impl ParallelExtend<String> for String

Extends a string with strings from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = String>,

impl ParallelExtend<OsString> for OsString

Extends an OS-string with strings from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = OsString>,

impl<'a> ParallelExtend<&'a char> for String

Extends a string with copied characters from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = &'a char>,

impl<'a> ParallelExtend<&'a str> for String

Extends a string with string slices from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = &'a str>,

impl<'a> ParallelExtend<&'a OsStr> for OsString

Extends an OS-string with string slices from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = &'a OsStr>,

impl<'a> ParallelExtend<Cow<'a, str>> for String

Extends a string with string slices from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = Cow<'a, str>>,

impl<'a> ParallelExtend<Cow<'a, OsStr>> for OsString

Extends an OS-string with string slices from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = Cow<'a, OsStr>>,

impl<'a, K, V> ParallelExtend<(&'a K, &'a V)> for BTreeMap<K, V>

where K: Copy + Ord + Send + Sync + 'a, V: Copy + Send + Sync + 'a,

Extends a B-tree map with copied items from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = (&'a K, &'a V)>,

impl<'a, K, V, S> ParallelExtend<(&'a K, &'a V)> for HashMap<K, V, S>

where K: Copy + Eq + Hash + Send + Sync + 'a, V: Copy + Send + Sync + 'a, S: BuildHasher + Send,

Extends a hash map with copied items from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = (&'a K, &'a V)>,

impl<'a, T> ParallelExtend<&'a T> for BinaryHeap<T>

where T: 'a + Copy + Ord + Send + Sync,

Extends a binary heap with copied items from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = &'a T>,

impl<'a, T> ParallelExtend<&'a T> for BTreeSet<T>

where T: 'a + Copy + Ord + Send + Sync,

Extends a B-tree set with copied items from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = &'a T>,

impl<'a, T> ParallelExtend<&'a T> for LinkedList<T>

where T: 'a + Copy + Send + Sync,

Extends a linked list with copied items from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = &'a T>,

impl<'a, T> ParallelExtend<&'a T> for VecDeque<T>

where T: 'a + Copy + Send + Sync,

Extends a deque with copied items from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = &'a T>,

impl<'a, T> ParallelExtend<&'a T> for Vec<T>

where T: 'a + Copy + Send + Sync,

Extends a vector with copied items from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = &'a T>,

impl<'a, T, S> ParallelExtend<&'a T> for HashSet<T, S>

where T: 'a + Copy + Eq + Hash + Send + Sync, S: BuildHasher + Send,

Extends a hash set with copied items from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = &'a T>,

impl<A, B, FromA, FromB> ParallelExtend<(A, B)> for (FromA, FromB)

where A: Send, B: Send, FromA: Send + ParallelExtend<A>, FromB: Send + ParallelExtend<B>,

fn par_extend<I>(&mut self, pi: I)

where I: IntoParallelIterator<Item = (A, B)>,

impl<K, V> ParallelExtend<(K, V)> for BTreeMap<K, V>

where K: Ord + Send, V: Send,

Extends a B-tree map with items from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = (K, V)>,

impl<K, V, S> ParallelExtend<(K, V)> for HashMap<K, V, S>

where K: Eq + Hash + Send, V: Send, S: BuildHasher + Send,

Extends a hash map with items from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = (K, V)>,

impl<L, R, A, B> ParallelExtend<Either<L, R>> for (A, B)

where L: Send, R: Send, A: Send + ParallelExtend<L>, B: Send + ParallelExtend<R>,

fn par_extend<I>(&mut self, pi: I)

where I: IntoParallelIterator<Item = Either<L, R>>,

impl<T> ParallelExtend<T> for BinaryHeap<T>

where T: Ord + Send,

Extends a binary heap with items from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = T>,

impl<T> ParallelExtend<T> for BTreeSet<T>

where T: Ord + Send,

Extends a B-tree set with items from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = T>,

impl<T> ParallelExtend<T> for LinkedList<T>

where T: Send,

Extends a linked list with items from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = T>,

impl<T> ParallelExtend<T> for VecDeque<T>

where T: Send,

Extends a deque with items from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = T>,

impl<T> ParallelExtend<T> for Vec<T>

where T: Send,

Extends a vector with items from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = T>,

impl<T, S> ParallelExtend<T> for HashSet<T, S>

where T: Eq + Hash + Send, S: BuildHasher + Send,

Extends a hash set with items from a parallel iterator.

fn par_extend<I>(&mut self, par_iter: I)

where I: IntoParallelIterator<Item = T>,

Implementors

impl<L, R, T> ParallelExtend<T> for Either<L, R>

where L: ParallelExtend<T>, R: ParallelExtend<T>, T: Send,

Either<L, R> can be extended if both L and R are parallel extendable.