Trait rayon::iter::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]);

Object Safety

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.

impl<T, FromT> ParallelExtend<T> for Collector<FromT>

where T: Send, FromT: Send + FromParallelIterator<T>,