airlang 0.25.0

Air is a minimalist and universal programming language.
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

use std::collections::hash_map::Entry;

use const_format::concatcp;
use derive_more::Deref;
use derive_more::DerefMut;

use crate::semantics::core::PREFIX_CELL;
use crate::semantics::val::Val;
use crate::type_::Key;
use crate::type_::Map;
use crate::type_::Text;
use crate::utils::hint::cold_path;

// todo design invariant
#[derive(Clone, PartialEq, Eq, Deref, DerefMut)]
pub struct Cfg {
    steps: u128,
    aborted: bool,
    #[deref]
    #[deref_mut]
    map: Map<Key, Val>,
}

impl Cfg {
    pub const ABORT_TYPE: &str = concatcp!(PREFIX_CELL, "error.abort.type");
    pub const ABORT_MSG: &str = concatcp!(PREFIX_CELL, "error.abort.message");

    pub const ABORT_TYPE_STEPS: &str = concatcp!(PREFIX_CELL, "steps");
    pub const ABORT_TYPE_BUG: &str = concatcp!(PREFIX_CELL, "bug");

    pub fn import(&self, key: Key) -> Option<&Val> {
        self.map.get(&key)
    }

    pub fn export(&mut self, key: Key, val: Val) -> Option<()> {
        if self.map.contains_key(&key) {
            return None;
        }
        self.map.insert(key, val);
        Some(())
    }

    pub fn extend(&mut self, key: Key, val: Val) {
        match self.map.entry(key.clone()) {
            Entry::Occupied(_) => panic!("expect a unique key, but {key} is already used"),
            Entry::Vacant(entry) => {
                entry.insert(val);
            },
        }
    }

    #[inline(always)]
    pub fn step(&mut self) -> bool {
        if self.aborted {
            cold_path();
            return false;
        }
        if self.steps == 0 {
            cold_path();
            self.export(
                Key::from_str_unchecked(Self::ABORT_TYPE),
                Val::Key(Key::from_str_unchecked(Self::ABORT_TYPE_STEPS)),
            );
            self.export(
                Key::from_str_unchecked(Self::ABORT_MSG),
                Val::Text(Text::from("out of steps").into()),
            );
            self.aborted = true;
            return false;
        }
        self.steps -= 1;
        true
    }

    pub fn set_steps(&mut self, n: u128) -> bool {
        if n > self.steps {
            return false;
        }
        self.steps = n;
        true
    }

    pub fn steps(&self) -> u128 {
        self.steps
    }

    #[cold]
    pub fn abort(&mut self) {
        self.aborted = true;
    }

    pub fn recover(&mut self) {
        self.steps = u128::MAX;
        self.aborted = false;
    }

    pub fn is_aborted(&self) -> bool {
        self.aborted
    }
}

impl From<Map<Key, Val>> for Cfg {
    fn from(map: Map<Key, Val>) -> Self {
        Self { steps: u128::MAX, aborted: false, map }
    }
}

impl From<Cfg> for Map<Key, Val> {
    fn from(cfg: Cfg) -> Self {
        cfg.map
    }
}

impl Default for Cfg {
    fn default() -> Self {
        Self { steps: u128::MAX, aborted: false, map: Map::default() }
    }
}