Struct par_map::ParMapBuilder

#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct ParMapBuilder<I> { /* fields omitted */ }

A builder used to configure the parallele work.

This struct is created by the with_nb_threads() method on ParIter. See its documentation for more.

Methods

impl<I: Iterator> ParMapBuilder<I>

Important traits for Map<I, B, F>

impl<I: Iterator, B: Send + 'static, F> Iterator for Map<I, B, F> where
    F: Sync + Send + 'static + Fn(I::Item) -> B,
    I::Item: Send + 'static,  type Item = B;

pub fn par_map<B, F>(self, f: F) -> Map<I, B, F> where     F: Sync + Send + 'static + Fn(I::Item) -> B,     B: Send + 'static,     I::Item: Send + 'static,

As ParMap::par_map, but with a custom number of threads

Example

use par_map::ParMap;
let a = [1, 2, 3];
let mut iter = a.iter()
    .cloned()
    .with_nb_threads(2)
    .par_map(|x| 2 * x);
assert_eq!(iter.next(), Some(2));
assert_eq!(iter.next(), Some(4));
assert_eq!(iter.next(), Some(6));
assert_eq!(iter.next(), None);

Important traits for FlatMap<I, U, F>

impl<I: Iterator, U: IntoIterator, F> Iterator for FlatMap<I, U, F> where
    F: Sync + Send + 'static + Fn(I::Item) -> U,
    U::Item: Send + 'static,
    I::Item: Send + 'static,  type Item = U::Item;

pub fn par_flat_map<U, F>(self, f: F) -> FlatMap<I, U, F> where     F: Sync + Send + 'static + Fn(I::Item) -> U,     U: IntoIterator,     U::Item: Send + 'static,     I::Item: Send + 'static,

As ParMap::par_flat_map, but with a custom number of threads

Example

use par_map::ParMap;
let words = ["alpha", "beta", "gamma"];
let merged: String = words.iter()
    .cloned() // as items must be 'static
    .with_nb_threads(2)
    .par_flat_map(|s| s.chars()) // exactly as std::iter::Iterator::flat_map
    .collect();
assert_eq!(merged, "alphabetagamma");

Important traits for PackedMap<'a, B>

impl<'a, B> Iterator for PackedMap<'a, B> type Item = <Box<Iterator<Item = B> + 'a> as Iterator>::Item;

pub fn par_packed_map<'a, B, F>(self, nb: usize, f: F) -> PackedMap<'a, B> where     F: Sync + Send + 'static + Fn(I::Item) -> B,     B: Send + 'static,     I::Item: Send + 'static,     Self: 'a,

As ParMap::par_packed_map, but with a custom number of threads

Example

use par_map::ParMap;
let a = [1, 2, 3];
let mut iter = a.iter()
    .cloned()
    .with_nb_threads(2)
    .par_packed_map(2, |x| 2 * x);
assert_eq!(iter.next(), Some(2));
assert_eq!(iter.next(), Some(4));
assert_eq!(iter.next(), Some(6));
assert_eq!(iter.next(), None);

Important traits for PackedFlatMap<'a, T>

impl<'a, T> Iterator for PackedFlatMap<'a, T> type Item = <Box<Iterator<Item = T> + 'a> as Iterator>::Item;

pub fn par_packed_flat_map<'a, U, F>(     self,     nb: usize,     f: F ) -> PackedFlatMap<'a, U::Item> where     F: Sync + Send + 'static + Fn(I::Item) -> U,     U: IntoIterator + 'a,     U::Item: Send + 'static,     I::Item: Send + 'static,     Self: 'a,

As ParMap::par_packed_flat_map, but with a custom number of threads

Example

use par_map::ParMap;
let words = ["alpha", "beta", "gamma"];
let merged: String = words.iter()
    .cloned()
    .with_nb_threads(2)
    .par_packed_flat_map(2, |s| s.chars())
    .collect();
assert_eq!(merged, "alphabetagamma");