chandeliers-sem 0.2.2

Semantics of Candle, a shallow embedding of Lustre in Rust
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use crate::macros::*;
use crate::traits::*;

#[allow(non_camel_case_types)]
#[derive(Debug, Default, Clone)]
pub struct counting {
    __trace: bool,
    __clock: usize,
    n: ty!(int+),
}

impl Step for counting {
    type Input = ();
    type Output = i64;
    fn step(&mut self, _: ()) -> ty!(int) {
        let n = later!(self <~ 0; lit!(0), var!(self <~ 1; n) + lit!(1));
        update!(self, n);
        tick!(self);
        n
    }
}

#[allow(non_camel_case_types)]
#[derive(Debug, Default, Clone)]
pub struct counting_twice {
    __trace: bool,
    __clock: usize,
    b: ty!(bool+),
    __nodes: (counting, counting),
}

#[allow(non_camel_case_types)]
#[derive(Debug, Default, Clone)]
pub struct counting_late {
    __trace: bool,
    __clock: usize,
    __nodes: (counting,),
}

impl Step for counting_twice {
    type Input = ();
    type Output = i64;
    fn step(&mut self, _: ()) -> ty!(int) {
        let b = later!(self <~ 0; lit!(true), ! var!(self <~ 1; b));
        update!(self, b);
        let _0 = substep!(self <~ 0; 0 => {});
        let _1 = substep!(self <~ 0; 1 => {});
        let res = ifx!((b) then { _0 } else { _1 });
        tick!(self);
        res
    }
}

impl Step for counting_late {
    type Input = ();
    type Output = i64;
    fn step(&mut self, _: ()) -> ty!(int) {
        let _0 = substep!(self <~ 2; 0 => {});
        let c = later!(self <~ 0; lit!(0), later!(self <~ 1; lit!(0), _0));
        tick!(self);
        c
    }
}

#[test]
fn counting_twice_behavior() {
    let mut count = counting_twice::default();
    for i in 0..10 {
        let j = count.step(());
        assert_is!(j, lit!(i));
    }
}

#[test]
fn counting_late_behavior() {
    let mut count = counting_late::default();
    for i in 0..10 {
        let j = count.step(());
        let actual_i = 0.max(i - 2);
        assert_is!(j, lit!(actual_i));
    }
}

#[allow(non_camel_case_types)]
#[derive(Debug, Default, Clone)]
pub struct counting_parallel {
    __trace: bool,
    __clock: usize,
    __nodes: (counting, counting),
}

impl Step for counting_parallel {
    type Input = ();
    type Output = (i64, i64);
    fn step(&mut self, _: ()) -> (ty!(int), ty!(int)) {
        let _0 = substep!(self <~ 0; 0 => {});
        let _1 = substep!(self <~ 0; 1 => {});
        let (a, b) = (_0, _1);
        tick!(self);
        (a, b)
    }
}

#[allow(non_camel_case_types)]
#[derive(Debug, Default, Clone)]
pub struct counting_parallel_tester {
    __trace: bool,
    __clock: usize,
    __nodes: (counting_parallel,),
}

impl Step for counting_parallel_tester {
    type Input = ();
    type Output = ();
    fn step(&mut self, _: ()) -> () {
        let _0 = substep!(self <~ 0; 0 => {});
        tick!(self);
    }
}

#[test]
fn counting_parallel_test() {
    let mut cpt = counting_parallel_tester::default();
    cpt.step(());
    cpt.step(());
    cpt.step(());
}