carlo 0.5.1

A simple interpreted 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

//! Environment manager for the Carlo language.

use std::collections::HashMap;

use crate::{
    Error,
    Expression,
};

pub struct Environment {
    variables: HashMap<String, Expression>,
}

impl Environment {
    /// Constructs a new environment.
    pub fn new() -> Self {
        Self {
            variables: HashMap::new(),
        }
    }

    /// Registers a variable in this environment.
    fn register(&mut self, name: &String, value: &Expression) {
        self.variables.insert(name.to_owned(), value.to_owned());
    }

    /// Looks up a variable in this environment.
    fn lookup(&self, name: &String) -> Expression {
        match self.variables.get(name) {
            Some (expr) => expr.to_owned(),
            None => {
                Error::UndeclaredVariable (name).warn();
                Expression::Null
            },
        }
    }

    /// Simplifies an expression in this environment.
    fn simplify(&mut self, expr: &Expression) -> Expression {
        use Expression::*;

        match expr {
            Assignment {
                left,
                right,
            } => {
                let sr = self.simplify(right);
                self.register(&left, &sr);
                sr.to_owned()
            },
            Reassignment {
                left,
                right,
            } => {
                let _ = self.lookup(&left);
                let sr = self.simplify(right);
                self.register(&left, &sr);
                sr.to_owned()
            },
            Float {
                value: _,
                kg: _,
                m: _,
                s: _,
                a: _,
                k: _,
                mol: _,
            } => expr.to_owned(),
            Identifier (s) => self.lookup(&s),
            BinOp {
                left,
                oper,
                right,
            } => {
                let sl = self.simplify(left);
                let sr = self.simplify(right);
                oper.simplify(&sl, &sr)
            },
            Null => Null,
        }
    }

    /// Evaluates a series of statements in this environment.
    pub fn evaluate(&mut self, expressions: &Vec<Expression>) -> String {
        let mut output = String::new();

        for expr in expressions {
            let out = self.simplify(expr);
            output.push_str(&format!("{}\n", out));
        }

        output
    }
}