salsa 0.26.1

A generic framework for on-demand, incrementalized computation (experimental)
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

#![cfg(feature = "inventory")]

#[salsa::interned(debug)]
struct InternedStruct<'db> {
    name: String,
}

#[salsa::input(debug)]
struct InputStruct {
    field: u32,
}

#[salsa::tracked(debug)]
struct TrackedStruct<'db> {
    field: u32,
}

#[salsa::tracked]
fn tracked_fn(db: &dyn salsa::Database, input: InputStruct) -> TrackedStruct<'_> {
    TrackedStruct::new(db, input.field(db) * 2)
}

#[test]
fn execute() {
    use salsa::plumbing::ZalsaDatabase;
    let db = salsa::DatabaseImpl::new();

    let interned1 = InternedStruct::new(&db, "Salsa".to_string());
    let interned2 = InternedStruct::new(&db, "Salsa2".to_string());

    // test interned structs
    let interned = InternedStruct::ingredient(db.zalsa())
        .entries(db.zalsa())
        .collect::<Vec<_>>();

    assert_eq!(interned.len(), 2);
    assert_eq!(interned[0].as_struct(), interned1);
    assert_eq!(interned[1].as_struct(), interned2);
    assert_eq!(interned[0].value().fields().0, "Salsa");
    assert_eq!(interned[1].value().fields().0, "Salsa2");

    // test input structs
    let input1 = InputStruct::new(&db, 22);

    let inputs = InputStruct::ingredient(&db)
        .entries(db.zalsa())
        .collect::<Vec<_>>();

    assert_eq!(inputs.len(), 1);
    assert_eq!(inputs[0].as_struct(), input1);
    assert_eq!(inputs[0].value().fields().0, 22);

    // test tracked structs
    let tracked1 = tracked_fn(&db, input1);
    assert_eq!(tracked1.field(&db), 44);

    let tracked = TrackedStruct::ingredient(&db)
        .entries(db.zalsa())
        .collect::<Vec<_>>();

    assert_eq!(tracked.len(), 1);
    assert_eq!(tracked[0].as_struct(), tracked1);
    assert_eq!(tracked[0].value().fields().0, tracked1.field(&db));
}