inc-complete 0.10.3

A library for writing incremental computations that re-execute the minimum number of steps when an input is changed
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

use inc_complete::{
    Db, Input, Storage,
    accumulate::{Accumulated, Accumulator},
    define_input, define_intermediate, intermediate,
    storage::{HashMapStorage, SingletonStorage},
};

// Simple calculator storage
#[derive(Default, Storage)]
struct Calculator {
    input_a: SingletonStorage<InputA>,
    input_b: SingletonStorage<InputB>,

    /// Explicitly specify the computation type
    #[inc_complete(computation = Sum)]
    sum: SingletonStorage<Sum>,

    #[inc_complete(skip)]
    #[allow(unused)]
    dummy: u32,

    log_storage: HashMapStorage<Accumulated<String>>,

    #[inc_complete(accumulate)]
    logs: Accumulator<String>,
}

// Input A
#[derive(Debug, Clone, Input)]
#[inc_complete(id = 0, output = i32, storage = Calculator)]
struct InputA;

// Input B
#[derive(Debug, Clone, Input)]
#[inc_complete(id = 1, output = i32, storage = Calculator)]
struct InputB;

// Sum computation
#[derive(Debug, Clone)]
struct Sum;

#[intermediate(id = 2)]
fn compute_sum(_sum: &Sum, db: &inc_complete::DbHandle<Calculator>) -> i32 {
    db.get(InputA) + db.get(InputB)
}

#[test]
fn test_simple_calculator() {
    let mut db = Db::<Calculator>::new();

    // Set inputs
    InputA.set(&mut db, 5);
    InputB.set(&mut db, 3);

    // Get sum
    let result = db.get(Sum);
    assert_eq!(result, 8);

    // Change input A
    InputA.set(&mut db, 10);
    let result = db.get(Sum);
    assert_eq!(result, 13);

    // Change input B
    InputB.set(&mut db, 7);
    let result = db.get(Sum);
    assert_eq!(result, 17);
}