glyph-runtime 0.0.1

Runtime execution engine for the Glyph 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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//! Tests for pattern matching functionality

#[cfg(test)]
mod tests {
    use crate::{compile_and_run_with_config, VMConfig};
    use glyph_types::Value;

    #[test]
    fn test_simple_literal_match() {
        let code = r#"
@program(name="test_literal_match", version="1.0", requires=[])

def main() -> int:
    let x = 42
    match x:
        case 42:
            return 1
        case 0:
            return 2
        case _:
            return 3
"#;

        let config = VMConfig::default();
        let result = compile_and_run_with_config(code, config).unwrap();
        assert_eq!(result, Value::Int(1));
    }

    #[test]
    fn test_variable_pattern() {
        let code = r#"
@program(name="test_variable_pattern", version="1.0", requires=[])

def main() -> int:
    let x = 100
    match x:
        case 42:
            return 1
        case y:
            return y
"#;

        let config = VMConfig::default();
        let result = compile_and_run_with_config(code, config).unwrap();
        assert_eq!(result, Value::Int(100));
    }

    #[test]
    fn test_wildcard_pattern() {
        let code = r#"
@program(name="test_wildcard_pattern", version="1.0", requires=[])

def main() -> int:
    let x = 999
    match x:
        case 42:
            return 1
        case 100:
            return 2
        case _:
            return 99
"#;

        let config = VMConfig::default();
        let result = compile_and_run_with_config(code, config).unwrap();
        assert_eq!(result, Value::Int(99));
    }

    #[test]
    fn test_string_pattern() {
        let code = r#"
@program(name="test_string_pattern", version="1.0", requires=[])

def main() -> str:
    let msg = "hello"
    match msg:
        case "hi":
            return "greeting"
        case "hello":
            return "world"
        case _:
            return "unknown"
"#;

        let config = VMConfig::default();
        let result = compile_and_run_with_config(code, config).unwrap();
        assert_eq!(result, Value::Str("world".to_string()));
    }

    #[test]
    fn test_bool_pattern() {
        let code = r#"
@program(name="test_bool_pattern", version="1.0", requires=[])

def main() -> str:
    let flag = True
    match flag:
        case True:
            return "yes"
        case False:
            return "no"
"#;

        let config = VMConfig::default();
        let result = compile_and_run_with_config(code, config).unwrap();
        assert_eq!(result, Value::Str("yes".to_string()));
    }

    #[test]
    fn test_none_pattern() {
        let code = r#"
@program(name="test_none_pattern", version="1.0", requires=[])

def main() -> int:
    let val = None
    match val:
        case None:
            return 0
        case _:
            return 1
"#;

        let config = VMConfig::default();
        let result = compile_and_run_with_config(code, config).unwrap();
        assert_eq!(result, Value::Int(0));
    }

    #[test]
    #[ignore] // Constructor patterns not yet implemented
    fn test_constructor_pattern() {
        let code = r#"
@program(name="test_constructor_pattern", version="1.0", requires=[])

def main() -> int:
    let result = Ok(42)
    match result:
        case Ok(value):
            return value
        case Err(msg):
            return -1
"#;

        let config = VMConfig::default();
        let result = compile_and_run_with_config(code, config).unwrap();
        assert_eq!(result, Value::Int(42));
    }
}