Trait rayon::iter::FromParallelIterator

pub trait FromParallelIterator<T> where
    T: Send, {
    fn from_par_iter<I>(par_iter: I) -> Self
    where
        I: IntoParallelIterator<Item = T>;
}

FromParallelIterator implements the conversion from a ParallelIterator. By implementing FromParallelIterator for a type, you define how it will be created from an iterator.

FromParallelIterator is used through ParallelIterator's collect() method.

Required methods

fn from_par_iter<I>(par_iter: I) -> Self where
    I: IntoParallelIterator<Item = T>, 

Loading content...

Implementations on Foreign Types

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

Collect items from a parallel iterator into a vector.

fn from_par_iter<I>(par_iter: I) -> Self where
    I: IntoParallelIterator<Item = T>, 

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

Collect items from a parallel iterator into a vecdeque.

fn from_par_iter<I>(par_iter: I) -> Self where
    I: IntoParallelIterator<Item = T>, 

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

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

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

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

impl<K, V, S> FromParallelIterator<(K, V)> for HashMap<K, V, S> where
    K: Eq + Hash + Send,
    V: Send,
    S: BuildHasher + Default + Send, 

Collect (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)>, 

impl<K, V> FromParallelIterator<(K, V)> for BTreeMap<K, V> where
    K: Ord + Send,
    V: Send, 

Collect (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)>, 

impl<V, S> FromParallelIterator<V> for HashSet<V, S> where
    V: Eq + Hash + Send,
    S: BuildHasher + Default + Send, 

Collect values from a parallel iterator into a hashset.

fn from_par_iter<I>(par_iter: I) -> Self where
    I: IntoParallelIterator<Item = V>, 

impl<V> FromParallelIterator<V> for BTreeSet<V> where
    V: Send + Ord, 

Collect values from a parallel iterator into a btreeset.

fn from_par_iter<I>(par_iter: I) -> Self where
    I: IntoParallelIterator<Item = V>, 

impl FromParallelIterator<char> for String

Collect characters from a parallel iterator into a string.

fn from_par_iter<I>(par_iter: I) -> Self where
    I: IntoParallelIterator<Item = char>, 

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

Collect characters from a parallel iterator into a string.

fn from_par_iter<I>(par_iter: I) -> Self where
    I: IntoParallelIterator<Item = &'a char>, 

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

Collect string slices from a parallel iterator into a string.

fn from_par_iter<I>(par_iter: I) -> Self where
    I: IntoParallelIterator<Item = &'a str>, 

impl FromParallelIterator<String> for String

Collect strings from a parallel iterator into one large string.

fn from_par_iter<I>(par_iter: I) -> Self where
    I: IntoParallelIterator<Item = String>, 

impl<'a, C: ?Sized, T> FromParallelIterator<T> for Cow<'a, C> where
    C: ToOwned,
    C::Owned: FromParallelIterator<T>,
    T: Send, 

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

impl<'a, C, T> FromParallelIterator<Option<T>> for Option<C> where
    C: FromParallelIterator<T>,
    T: Send, 

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

impl<'a, C, T, E> FromParallelIterator<Result<T, E>> for Result<C, E> where
    C: FromParallelIterator<T>,
    T: Send,
    E: Send, 

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

Loading content...

Implementors

Loading content...