Struct easy_parallel::Parallel

#[must_use]pub struct Parallel<'a, T> { /* fields omitted */ }

A builder that runs closures in parallel.

Implementations

impl<'a, T> Parallel<'a, T>

pub fn new() -> Parallel<'a, T>

Creates a builder for running closures in parallel.

Examples

use easy_parallel::Parallel;

let p = Parallel::<()>::new();

pub fn add<F>(self, f: F) -> Parallel<'a, T> where
    F: FnOnce() -> T + Send + 'a,
    T: Send + 'a, 

Adds a closure to the list.

Examples

use easy_parallel::Parallel;

Parallel::new()
    .add(|| println!("hello from a thread"))
    .run();

pub fn each<A, I, F>(self, iter: I, f: F) -> Parallel<'a, T> where
    I: IntoIterator<Item = A>,
    F: FnOnce(A) -> T + Clone + Send + 'a,
    A: Send + 'a,
    T: Send + 'a, 

Adds a cloned closure for each item in an iterator.

Each clone of the closure takes an item as an argument.

Examples

use easy_parallel::Parallel;

Parallel::new()
    .each(0..5, |i| println!("hello from thread #{}", i))
    .run();

pub fn run(self) -> Vec<T> where
    T: Send + 'a, 

Spawns a thread for each closure and collects their results.

Results are collected in the order in which threads completed.

If a closure panics, panicking will resume in the main thread after all threads are joined.

Examples

use easy_parallel::Parallel;
use std::thread;
use std::time::Duration;

let res = Parallel::new()
    .each(0..5, |i| {
        thread::sleep(Duration::from_secs(5 - i));
        i
    })
    .run();

// Threads finish in reverse order because of how they sleep.
assert_eq!(res, [4, 3, 2, 1, 0]);

Trait Implementations

impl<'_, T> Debug for Parallel<'_, T>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'a, T: Default> Default for Parallel<'a, T>

fn default() -> Parallel<'a, T>

Returns the "default value" for a type.