Trait rayon::iter::FromParallelIterator [−][src]
pub trait FromParallelIterator<T> where
T: Send, { fn from_par_iter<I>(par_iter: I) -> Self
where
I: IntoParallelIterator<Item = T>; }
FromParallelIterator
implements the creation of a collection
from a ParallelIterator
. By implementing
FromParallelIterator
for a given type, you define how it will be
created from an iterator.
FromParallelIterator
is used through ParallelIterator
’s collect()
method.
Examples
Implementing FromParallelIterator
for your type:
use rayon::prelude::*; use std::mem; struct BlackHole { mass: usize, } impl<T: Send> FromParallelIterator<T> for BlackHole { fn from_par_iter<I>(par_iter: I) -> Self where I: IntoParallelIterator<Item = T> { let par_iter = par_iter.into_par_iter(); BlackHole { mass: par_iter.count() * mem::size_of::<T>(), } } } let bh: BlackHole = (0i32..1000).into_par_iter().collect(); assert_eq!(bh.mass, 4000);
Required methods
fn from_par_iter<I>(par_iter: I) -> Self where
I: IntoParallelIterator<Item = T>,
[src]
I: IntoParallelIterator<Item = T>,
Creates an instance of the collection from the parallel iterator par_iter
.
If your collection is not naturally parallel, the easiest (and
fastest) way to do this is often to collect par_iter
into a
LinkedList
or other intermediate data structure and then
sequentially extend your collection. However, a more ‘native’
technique is to use the par_iter.fold
or
par_iter.fold_with
methods to create the collection.
Alternatively, if your collection is ‘natively’ parallel, you
can use par_iter.for_each
to process each element in turn.
Implementations on Foreign Types
impl<T> FromParallelIterator<T> for Vec<T> where
T: Send,
[src]
impl<T> FromParallelIterator<T> for Vec<T> where
T: Send,
[src]Collects items from a parallel iterator into a vector.
fn from_par_iter<I>(par_iter: I) -> Self where
I: IntoParallelIterator<Item = T>,
[src]
I: IntoParallelIterator<Item = T>,
impl<T> FromParallelIterator<T> for VecDeque<T> where
T: Send,
[src]
impl<T> FromParallelIterator<T> for VecDeque<T> where
T: Send,
[src]Collects items from a parallel iterator into a vecdeque.
fn from_par_iter<I>(par_iter: I) -> Self where
I: IntoParallelIterator<Item = T>,
[src]
I: IntoParallelIterator<Item = T>,
impl<T> FromParallelIterator<T> for BinaryHeap<T> where
T: Ord + Send,
[src]
impl<T> FromParallelIterator<T> for BinaryHeap<T> where
T: Ord + Send,
[src]Collects items from a parallel iterator into a binaryheap. The heap-ordering is calculated serially after all items are collected.
fn from_par_iter<I>(par_iter: I) -> Self where
I: IntoParallelIterator<Item = T>,
[src]
I: IntoParallelIterator<Item = T>,
impl<T> FromParallelIterator<T> for LinkedList<T> where
T: Send,
[src]
impl<T> FromParallelIterator<T> for LinkedList<T> where
T: Send,
[src]Collects items from a parallel iterator into a freshly allocated linked list.
fn from_par_iter<I>(par_iter: I) -> Self where
I: IntoParallelIterator<Item = T>,
[src]
I: IntoParallelIterator<Item = T>,
impl<K, V, S> FromParallelIterator<(K, V)> for HashMap<K, V, S> where
K: Eq + Hash + Send,
V: Send,
S: BuildHasher + Default + Send,
[src]
impl<K, V, S> FromParallelIterator<(K, V)> for HashMap<K, V, S> where
K: Eq + Hash + Send,
V: Send,
S: BuildHasher + Default + Send,
[src]Collects (key, value) pairs from a parallel iterator into a hashmap. If multiple pairs correspond to the same key, then the ones produced earlier in the parallel iterator will be overwritten, just as with a sequential iterator.
fn from_par_iter<I>(par_iter: I) -> Self where
I: IntoParallelIterator<Item = (K, V)>,
[src]
I: IntoParallelIterator<Item = (K, V)>,
impl<K, V> FromParallelIterator<(K, V)> for BTreeMap<K, V> where
K: Ord + Send,
V: Send,
[src]
impl<K, V> FromParallelIterator<(K, V)> for BTreeMap<K, V> where
K: Ord + Send,
V: Send,
[src]Collects (key, value) pairs from a parallel iterator into a btreemap. If multiple pairs correspond to the same key, then the ones produced earlier in the parallel iterator will be overwritten, just as with a sequential iterator.
fn from_par_iter<I>(par_iter: I) -> Self where
I: IntoParallelIterator<Item = (K, V)>,
[src]
I: IntoParallelIterator<Item = (K, V)>,
impl<V, S> FromParallelIterator<V> for HashSet<V, S> where
V: Eq + Hash + Send,
S: BuildHasher + Default + Send,
[src]
impl<V, S> FromParallelIterator<V> for HashSet<V, S> where
V: Eq + Hash + Send,
S: BuildHasher + Default + Send,
[src]Collects values from a parallel iterator into a hashset.
fn from_par_iter<I>(par_iter: I) -> Self where
I: IntoParallelIterator<Item = V>,
[src]
I: IntoParallelIterator<Item = V>,
impl<V> FromParallelIterator<V> for BTreeSet<V> where
V: Send + Ord,
[src]
impl<V> FromParallelIterator<V> for BTreeSet<V> where
V: Send + Ord,
[src]Collects values from a parallel iterator into a btreeset.
fn from_par_iter<I>(par_iter: I) -> Self where
I: IntoParallelIterator<Item = V>,
[src]
I: IntoParallelIterator<Item = V>,
impl FromParallelIterator<char> for String
[src]
impl FromParallelIterator<char> for String
[src]Collects characters from a parallel iterator into a string.
fn from_par_iter<I>(par_iter: I) -> Self where
I: IntoParallelIterator<Item = char>,
[src]
I: IntoParallelIterator<Item = char>,
impl<'a> FromParallelIterator<&'a char> for String
[src]
impl<'a> FromParallelIterator<&'a char> for String
[src]Collects characters from a parallel iterator into a string.
fn from_par_iter<I>(par_iter: I) -> Self where
I: IntoParallelIterator<Item = &'a char>,
[src]
I: IntoParallelIterator<Item = &'a char>,
impl<'a> FromParallelIterator<&'a str> for String
[src]
impl<'a> FromParallelIterator<&'a str> for String
[src]Collects string slices from a parallel iterator into a string.
fn from_par_iter<I>(par_iter: I) -> Self where
I: IntoParallelIterator<Item = &'a str>,
[src]
I: IntoParallelIterator<Item = &'a str>,
impl FromParallelIterator<String> for String
[src]
impl FromParallelIterator<String> for String
[src]Collects strings from a parallel iterator into one large string.
fn from_par_iter<I>(par_iter: I) -> Self where
I: IntoParallelIterator<Item = String>,
[src]
I: IntoParallelIterator<Item = String>,
impl<'a> FromParallelIterator<Cow<'a, str>> for String
[src]
impl<'a> FromParallelIterator<Cow<'a, str>> for String
[src]Collects string slices from a parallel iterator into a string.
fn from_par_iter<I>(par_iter: I) -> Self where
I: IntoParallelIterator<Item = Cow<'a, str>>,
[src]
I: IntoParallelIterator<Item = Cow<'a, str>>,
impl<'a, C: ?Sized, T> FromParallelIterator<T> for Cow<'a, C> where
C: ToOwned,
C::Owned: FromParallelIterator<T>,
T: Send,
[src]
impl<'a, C: ?Sized, T> FromParallelIterator<T> for Cow<'a, C> where
C: ToOwned,
C::Owned: FromParallelIterator<T>,
T: Send,
[src]Collects an arbitrary Cow
collection.
Note, the standard library only has FromIterator
for Cow<'a, str>
and
Cow<'a, [T]>
, because no one thought to add a blanket implementation
before it was stabilized.
fn from_par_iter<I>(par_iter: I) -> Self where
I: IntoParallelIterator<Item = T>,
[src]
I: IntoParallelIterator<Item = T>,
impl FromParallelIterator<()> for ()
[src]
impl FromParallelIterator<()> for ()
[src]Collapses all unit items from a parallel iterator into one.
This is more useful when combined with higher-level abstractions, like
collecting to a Result<(), E>
where you only care about errors:
use std::io::*; use rayon::prelude::*; let data = vec![1, 2, 3, 4, 5]; let res: Result<()> = data.par_iter() .map(|x| writeln!(stdout(), "{}", x)) .collect(); assert!(res.is_ok());
fn from_par_iter<I>(par_iter: I) -> Self where
I: IntoParallelIterator<Item = ()>,
[src]
I: IntoParallelIterator<Item = ()>,
impl<C, T> FromParallelIterator<Option<T>> for Option<C> where
C: FromParallelIterator<T>,
T: Send,
[src]
impl<C, T> FromParallelIterator<Option<T>> for Option<C> where
C: FromParallelIterator<T>,
T: Send,
[src]Collect an arbitrary Option
-wrapped collection.
If any item is None
, then all previous items collected are discarded,
and it returns only None
.
fn from_par_iter<I>(par_iter: I) -> Self where
I: IntoParallelIterator<Item = Option<T>>,
[src]
I: IntoParallelIterator<Item = Option<T>>,
impl<C, T, E> FromParallelIterator<Result<T, E>> for Result<C, E> where
C: FromParallelIterator<T>,
T: Send,
E: Send,
[src]
impl<C, T, E> FromParallelIterator<Result<T, E>> for Result<C, E> where
C: FromParallelIterator<T>,
T: Send,
E: Send,
[src]Collect an arbitrary Result
-wrapped collection.
If any item is Err
, then all previous Ok
items collected are
discarded, and it returns that error. If there are multiple errors, the
one returned is not deterministic.
fn from_par_iter<I>(par_iter: I) -> Self where
I: IntoParallelIterator<Item = Result<T, E>>,
[src]
I: IntoParallelIterator<Item = Result<T, E>>,