nyandere 0.1.2

i help with keeping track of purchases. meow
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

//! Process and understand.
//!
//! What is semantically valid?

pub mod cmd;
pub mod model;
pub mod resolve;

pub use resolve::{Emerge, Resolve};

use std::ops::Deref;

use crate::{
    Map, Name,
    aux::NotOrd,
    error,
    ext::{business::Value, shop::Gtin},
    runtime::{
        cmd::{Output, Run},
        model::{Concept, Entity, Object, Pair},
    },
    syntax::ast::Script,
};

#[derive(NotOrd!, Default)]
pub struct Runtime {
    state: State,
}

impl Runtime {
    #[must_use]
    pub fn state(&self) -> &State {
        &self.state
    }

    #[must_use]
    pub fn to_state(self) -> State {
        self.state
    }
}

impl Runtime {
    /// Initializes an empty runtime.
    ///
    /// Run [`cmd::Create`] to start filling it afterwards.
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    /// Evaluate a whole parsed [`Script`].
    ///
    /// # Error
    ///
    /// Note that in the case of an error,
    /// the runtime is not rolled back
    /// and still holds the state
    /// just before the invalid command.
    pub fn run(&mut self, script: Script) -> Result<(), error::Construction> {
        for stmt in script.0 {
            let cmd = cmd::construct(stmt, &self.state)?;
            if let Some(msg) = self.step(cmd) {
                println!("{msg}");
            }
        }

        Ok(())
    }

    pub fn step(&mut self, cmd: Box<dyn Run>) -> Output {
        cmd.run(&mut self.state)
    }
}

impl Deref for Runtime {
    type Target = State;

    fn deref(&self) -> &Self::Target {
        &self.state
    }
}

// TODO: generate this automatically
/// An index of directly accessible actors.
///
/// # On being complete
///
/// Note that over time,
/// actors might be come inaccessible
/// as their names (or GTIN, in case of a concept)
/// can be shadowed.
/// In this case, they will never become accessible again.
/// ***However***, they will still be referred to
/// when referenced elsewhere.
/// 
/// For example, take this script:
///
/// ```text
/// create concept C price 1€
/// create object O
/// create concept C price 2€
/// ```
///
/// After this script was ran,
/// object `O` still the former concept `C` with price 1€
/// as parent.
/// However, only the latter concept `C` with price 2€
/// can be referred to by its name.
#[derive(NotOrd!, Default)]
pub struct State {
    // not much use -- yet, that is
    pub entities: Map<Name, Entity>,
    pub concepts: Map<Name, Concept>,
    pub concepts_gtin: Map<Gtin, Concept>,
    pub objects: Map<Name, Object>,

    // TODO: think about how to store this smarter.
    // maybe with debit-credit bookkeeping applied as in 2 maps?
    pub balances: Map<Pair, Value>,
}