ggen-core 26.7.3

Core graph-aware code generation engine
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

use crate::semantic_bit::law::Law;
use crate::semantic_bit::phase::*;
use std::marker::PhantomData;

/// A machine that enforces operational law via typestate.
pub struct Machine<L: Law, P> {
    pub field: L::Field,
    _marker: PhantomData<(L, P)>,
}

impl<L: Law> Machine<L, Input> {
    pub fn new(field: L::Field) -> Self {
        Self {
            field,
            _marker: PhantomData,
        }
    }

    pub fn validate(self) -> std::result::Result<Machine<L, Validated>, L::Error> {
        let field = L::validate(self.field)?;
        Ok(Machine {
            field,
            _marker: PhantomData,
        })
    }
}

impl<L: Law> Machine<L, Validated> {
    pub fn select(self) -> (Machine<L, Selected<L::Condition>>, L::Condition) {
        let condition = L::select(self.field);
        (
            Machine {
                field: self.field,
                _marker: PhantomData,
            },
            condition,
        )
    }
}

impl<L: Law, C> Machine<L, Selected<C>> {
    pub fn admit(self, condition: L::Condition) -> Machine<L, Admitted<L::Condition>> {
        let _ = L::admit(self.field, condition);
        Machine {
            field: self.field,
            _marker: PhantomData,
        }
    }
}

impl<L: Law, C> Machine<L, Admitted<C>> {
    pub fn receipt(self, sequence: u64) -> (Machine<L, Receipted<L::Receipt>>, L::Receipt) {
        let condition = L::select(self.field);
        let admitted = L::admit(self.field, condition);
        let receipt = L::receipt(admitted, sequence);
        (
            Machine {
                field: self.field,
                _marker: PhantomData,
            },
            receipt,
        )
    }
}

impl<L: Law, R> Machine<L, Receipted<R>> {
    pub fn exit(self, receipt: L::Receipt) -> (Machine<L, Exited<L::Exit>>, L::Exit) {
        let exit = L::exit(receipt);
        (
            Machine {
                field: self.field,
                _marker: PhantomData,
            },
            exit,
        )
    }
}