fn_graph 0.18.0

Runs interdependent logic concurrently, starting each function when predecessors have completed.
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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

use fn_graph::{Edge, FnGraphBuilder, WouldCycle};
use resman::{IntoFnRes, Resources};

fn main() -> Result<(), WouldCycle<Edge>> {
    let mut resources = Resources::new();
    resources.insert(0u32);

    let fn_graph = {
        let mut fn_graph_builder = FnGraphBuilder::new();
        let [double, cube, add_five] = fn_graph_builder.add_fns([
            double.into_fn_res(),
            cube.into_fn_res(),
            add_five.into_fn_res(),
        ]);
        fn_graph_builder.add_logic_edges([(add_five, double), (double, cube)])?;
        fn_graph_builder.build()
    };

    fn_graph
        .iter()
        .map(|f| f.call(&resources))
        .for_each(|event| {
            println!(
                "{:8}: {:>4} -> {:>4}",
                event.fn_name, event.n_before, event.n_after
            )
        });

    Ok(())
}

fn add_five(n: &mut u32) -> Event {
    let n_before = *n;
    let n_after = n_before + 5;
    *n = n_after;

    Event {
        fn_name: "add_five",
        n_before,
        n_after,
    }
}

fn double(n: &mut u32) -> Event {
    let n_before = *n;
    let n_after = n_before * 2;
    *n = n_after;

    Event {
        fn_name: "double",
        n_before,
        n_after,
    }
}

fn cube(n: &mut u32) -> Event {
    let n_before = *n;
    let n_after = n_before * n_before * n_before;
    *n = n_after;

    Event {
        fn_name: "cube",
        n_before,
        n_after,
    }
}

#[derive(Debug)]
struct Event {
    fn_name: &'static str,
    n_before: u32,
    n_after: u32,
}