orx-parallel 4.0.0

Performant parallel computations with an expressive iterator API.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

use alloc::vec;
use alloc::vec::Vec;
use core::ops::Range;
use rand::prelude::*;
use rand_chacha::ChaCha8Rng;

pub const RANGE: Range<u64> = 0..100_000;

#[derive(Debug, Clone)]
pub struct Node {
    pub value: u64,
    pub children: Vec<Node>,
}

impl Node {
    pub fn build_tree(depth: usize, fan_out: usize, rng: &mut ChaCha8Rng) -> Self {
        let children = if depth == 0 {
            vec![]
        } else {
            (0..fan_out)
                .map(|_| Self::build_tree(depth - 1, fan_out, rng))
                .collect()
        };

        let value = rng.random_range(RANGE);
        Self { value, children }
    }

    #[allow(dead_code)]
    pub fn corresponds(self: &Node, search_value: u64) -> bool {
        self.value == search_value
    }
}

pub fn flatten<I, E>(initial: impl IntoIterator<Item = I::Item>, extend: &E) -> Vec<I::Item>
where
    I: IntoIterator,
    E: Fn(&I::Item) -> I + Send + Sync,
{
    fn collect_into<I, E>(
        extend: &E,
        initial: impl IntoIterator<Item = I::Item>,
        dest: &mut Vec<I::Item>,
    ) where
        I: IntoIterator,
        E: Fn(&I::Item) -> I + Send + Sync,
    {
        for x in initial {
            let children = extend(&x);
            collect_into(extend, children, dest);
            dest.push(x);
        }
    }

    let mut dest = vec![];
    collect_into(extend, initial, &mut dest);
    dest
}