anchors 0.6.0

async incremental computations
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

use anchors::expert::{Anchor, AnchorExt, Var, VarSetter};
use anchors::singlethread::Engine;

const NODE_COUNT: u64 = 100;
const ITER_COUNT: u64 = 500000;
const OBSERVED: bool = true;

fn main() {
    let mut engine = Engine::new_with_max_height(128);
    let (first_num, set_first_num) = Var::new(0u64);
    let mut node = first_num;
    for _ in 0..NODE_COUNT {
        node = node.map(|val| val + 1);
    }
    if OBSERVED {
        engine.mark_observed(&node);
    }
    assert_eq!(engine.get(&node), NODE_COUNT);
    iter(node, engine, set_first_num);
}

#[inline(never)]
fn iter(
    node: Anchor<u64, Engine>,
    mut engine: Engine,
    set_first_num: VarSetter<u64, <Engine as anchors::expert::Engine>::DirtyHandle>,
) {
    let mut update_number = 0;
    for i in 0..ITER_COUNT {
        if i % (ITER_COUNT / 100) == 0 {
            println!("{}%", (i * 100) / (ITER_COUNT));
        }
        update_number += 1;
        set_first_num.set(update_number);
        assert_eq!(engine.get(&node), update_number + NODE_COUNT);
    }
}