Trait stdcli::prelude::rayon::prelude::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>, 

Implementations on Foreign Types

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) -> BTreeSet<V> where
    I: IntoParallelIterator<Item = V>, 

impl FromParallelIterator<String> for String

Collect strings from a parallel iterator into one large string.

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

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) -> BTreeMap<K, V> where
    I: IntoParallelIterator<Item = (K, V)>, 

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) -> String where
    I: IntoParallelIterator<Item = &'a str>, 

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) -> LinkedList<T> where
    I: IntoParallelIterator<Item = T>, 

impl<K, V, S> FromParallelIterator<(K, V)> for HashMap<K, V, S> where
    K: Eq + Hash + Send,
    S: BuildHasher + Default + Send,
    V: 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) -> HashMap<K, V, S> where
    I: IntoParallelIterator<Item = (K, V)>, 

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) -> Option<C> where
    I: IntoParallelIterator<Item = Option<T>>, 

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

Collect values from a parallel iterator into a hashset.

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

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

Collect characters from a parallel iterator into a string.

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

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) -> BinaryHeap<T> 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) -> VecDeque<T> where
    I: IntoParallelIterator<Item = T>, 

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

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) -> Cow<'a, C> where
    I: IntoParallelIterator<Item = T>, 

impl<'a, C, T, E> FromParallelIterator<Result<T, E>> for Result<C, E> where
    C: FromParallelIterator<T>,
    E: Send,
    T: 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) -> Result<C, E> where
    I: IntoParallelIterator<Item = Result<T, E>>, 

impl FromParallelIterator<char> for String

Collect characters from a parallel iterator into a string.

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

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) -> Vec<T> where
    I: IntoParallelIterator<Item = T>, 

Implementors