maid-lang 1.1.0

Maid 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

use crate::{errors::standard_error::StandardError, values::value::Value};

#[derive(Clone)]
pub struct RuntimeResult {
    pub value: Option<Value>,
    pub error: Option<StandardError>,
    pub func_return_value: Option<Value>,
    pub loop_should_continue: bool,
    pub loop_should_break: bool,
}

impl RuntimeResult {
    pub fn new() -> Self {
        Self {
            value: None,
            error: None,
            func_return_value: None,
            loop_should_continue: false,
            loop_should_break: false,
        }
    }

    pub fn reset(&mut self) {
        self.value = None;
        self.error = None;
        self.func_return_value = None;
        self.loop_should_continue = false;
        self.loop_should_break = false;
    }

    pub fn register(&mut self, result: RuntimeResult) -> Option<Value> {
        self.error = result.error;
        self.func_return_value = result.func_return_value;
        self.loop_should_continue = result.loop_should_continue;
        self.loop_should_break = result.loop_should_break;

        result.value
    }

    pub fn success(&mut self, value: Option<Value>) -> RuntimeResult {
        self.reset();
        self.value = value;

        self.clone()
    }

    pub fn success_return(&mut self, value: Option<Value>) -> RuntimeResult {
        self.reset();
        self.func_return_value = value;

        self.clone()
    }

    pub fn success_continue(&mut self) -> RuntimeResult {
        self.reset();
        self.loop_should_continue = true;

        self.clone()
    }

    pub fn success_break(&mut self) -> RuntimeResult {
        self.reset();
        self.loop_should_break = true;

        self.clone()
    }

    pub fn failure(&mut self, error: Option<StandardError>) -> RuntimeResult {
        self.reset();
        self.error = error;

        self.clone()
    }

    pub fn should_return(&self) -> bool {
        self.error.is_some()
            || self.func_return_value.is_some()
            || self.loop_should_continue
            || self.loop_should_break
    }
}