rayon::iter

Trait ParallelExtend

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

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§

Source

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§

Source§

impl ParallelExtend<char> for String

Extends a string with characters from a parallel iterator.

Source§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = char>,

Source§

impl ParallelExtend<()> for ()

Collapses all unit items from a parallel iterator into one.

Source§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = ()>,

Source§

impl ParallelExtend<String> for String

Extends a string with strings from a parallel iterator.

Source§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = String>,

Source§

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

Extends a string with copied characters from a parallel iterator.

Source§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = &'a char>,

Source§

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

Extends a string with string slices from a parallel iterator.

Source§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = &'a str>,

Source§

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

Extends a string with string slices from a parallel iterator.

Source§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = Cow<'a, str>>,

Source§

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.

Source§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = (&'a K, &'a V)>,

Source§

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.

Source§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = (&'a K, &'a V)>,

Source§

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.

Source§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = &'a T>,

Source§

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.

Source§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = &'a T>,

Source§

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.

Source§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = &'a T>,

Source§

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.

Source§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = &'a T>,

Source§

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.

Source§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = &'a T>,

Source§

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.

Source§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = &'a T>,

Source§

impl<A, B, FromA, FromB> ParallelExtend<(A, B)> for (FromA, FromB)
where A: Send, B: Send, FromA: Send + ParallelExtend<A>, FromB: Send + ParallelExtend<B>,

Source§

fn par_extend<I>(&mut self, pi: I)
where I: IntoParallelIterator<Item = (A, B)>,

Source§

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.

Source§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = (K, V)>,

Source§

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.

Source§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = (K, V)>,

Source§

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>,

Source§

fn par_extend<I>(&mut self, pi: I)
where I: IntoParallelIterator<Item = Either<L, R>>,

Source§

impl<T> ParallelExtend<T> for BinaryHeap<T>
where T: Ord + Send,

Extends a binary heap with items from a parallel iterator.

Source§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = T>,

Source§

impl<T> ParallelExtend<T> for BTreeSet<T>
where T: Ord + Send,

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

Source§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = T>,

Source§

impl<T> ParallelExtend<T> for LinkedList<T>
where T: Send,

Extends a linked list with items from a parallel iterator.

Source§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = T>,

Source§

impl<T> ParallelExtend<T> for VecDeque<T>
where T: Send,

Extends a deque with items from a parallel iterator.

Source§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = T>,

Source§

impl<T> ParallelExtend<T> for Vec<T>
where T: Send,

Extends a vector with items from a parallel iterator.

Source§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = T>,

Source§

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.

Source§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = T>,

Implementors§

Source§

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.