tool for me to use if i drop nixos
fix certain evaluation problems
+53
-26
+7
-7
crates/dmx/src/builtins.rs
+7
-7
crates/dmx/src/builtins.rs
···
42
42
)));
43
43
}
44
44
45
-
let t = &args[0];
46
-
match &**t {
47
-
Expr::Map(t) => {
48
-
for (k, v) in t {
49
-
scope.set(k, Arc::clone(v));
45
+
let t = scope.eval(ExprRef::clone(&args[0]))?;
46
+
match &*t {
47
+
Expr::Map(m) => {
48
+
for (k, v) in m {
49
+
scope.set(k, ExprRef::clone(v));
50
50
}
51
-
let args = &args[1..];
52
-
scope.eval_ast(&args)
51
+
let ast = &args[1..];
52
+
scope.eval_ast(&ast)
53
53
}
54
54
_ => {
55
55
return Err(RuntimeError::InvalidArguments(format!(
+8
crates/dmx/src/engine.rs
+8
crates/dmx/src/engine.rs
+15
-11
crates/dmx/src/engine/parser.rs
+15
-11
crates/dmx/src/engine/parser.rs
···
42
42
TokenValue::LParen => {
43
43
let mut list = vec![];
44
44
45
-
while let Some(next_token) = token_iter.next() {
46
-
match &next_token.value {
47
-
TokenValue::RParen => break,
48
-
_ => {
49
-
let expr = parse_expr(&next_token, token_iter)?;
45
+
#[allow(irrefutable_let_patterns)]
46
+
while let next_token = token_iter.next() {
47
+
match &next_token.as_ref().map(|v| &v.value) {
48
+
Some(TokenValue::RParen) => break,
49
+
Some(_) => {
50
+
let expr = parse_expr(next_token.as_ref().unwrap(), token_iter)?;
50
51
list.push(expr);
51
52
}
53
+
None => return Err(ParseError::UnexpectedEOF(line)),
52
54
}
53
55
}
54
56
···
58
60
let mut map = Map::new();
59
61
let mut need_comma = false;
60
62
61
-
while let Some(next_token) = token_iter.next() {
62
-
match &next_token.value {
63
-
TokenValue::RBrace => break,
64
-
TokenValue::Symbol(sym) if !need_comma => {
63
+
#[allow(irrefutable_let_patterns)]
64
+
while let next_token = token_iter.next() {
65
+
match &next_token.map(|v| v.value) {
66
+
Some(TokenValue::RBrace) => break,
67
+
Some(TokenValue::Symbol(sym)) if !need_comma => {
65
68
need_comma = true;
66
69
let Some(value_token) = token_iter.next() else {
67
70
return Err(ParseError::UnexpectedEOF(line));
···
69
72
let val = parse_expr(&value_token, token_iter)?;
70
73
map.insert(sym.clone(), val);
71
74
}
72
-
TokenValue::Comma => need_comma = false,
73
-
_ => return Err(ParseError::UnexpectedToken(line, next_token.value)),
75
+
Some(TokenValue::Comma) => need_comma = false,
76
+
Some(v) => return Err(ParseError::UnexpectedToken(line, v.clone())),
77
+
None => return Err(ParseError::UnexpectedEOF(line)),
74
78
}
75
79
}
76
80
+10
-4
crates/dmx/src/scope.rs
+10
-4
crates/dmx/src/scope.rs
···
1
-
use crate::{Expr, RuntimeError};
1
+
use crate::{Expr, Map, RuntimeError};
2
2
use std::{
3
3
collections::HashMap,
4
4
sync::{Arc, Mutex, Weak},
···
85
85
let func = self.eval(Arc::clone(func))?;
86
86
self.call_function(func, args)?
87
87
}
88
+
Expr::Map(m) => {
89
+
let mut m2 = Map::new();
90
+
for (k, v) in m {
91
+
m2.insert(k.to_owned(), self.eval(Arc::clone(v))?);
92
+
}
93
+
Arc::new(Expr::Map(m2))
94
+
}
88
95
_ => value,
89
96
})
90
97
}
···
99
106
Expr::PrimOp(f) => {
100
107
let args: Vec<_> = args
101
108
.iter()
102
-
.map(|c| self.eval(Arc::clone(&c)))
103
-
.filter_map(|p| p.ok())
109
+
.flat_map(|c| self.eval(Arc::clone(&c))) // TODO: find clean way to handle errors
104
110
.collect();
105
111
(f.0)(branch, &args)
106
112
}
···
115
121
116
122
let iter = f.arglist.iter().zip(args.iter());
117
123
for (name, value) in iter {
118
-
branch.set(name, Arc::clone(&value));
124
+
branch.set(name, branch.eval(Arc::clone(value))?);
119
125
}
120
126
121
127
branch.eval_ast(&f.body)
+9
crates/dmx/src/tests/hello.dmx
+9
crates/dmx/src/tests/hello.dmx
+4
-4
crates/dmx/src/value.rs
+4
-4
crates/dmx/src/value.rs
···
88
88
(Expr::Int(a), Expr::Int(b)) => Expr::Int(a + b),
89
89
(Expr::Float(a), Expr::Float(b)) => Expr::Float(a + b),
90
90
(Expr::Float(a), Expr::Int(b)) => Expr::Float(a + *b as Float),
91
-
(Expr::Int(a), Expr::Float(b)) => Expr::Int(a + *b as Int),
91
+
(Expr::Int(a), Expr::Float(b)) => Expr::Float(*a as Float + *b),
92
92
// TODO: better handle invalid types
93
93
_ => self.clone(),
94
94
}
···
99
99
(Expr::Int(a), Expr::Int(b)) => Expr::Int(a - b),
100
100
(Expr::Float(a), Expr::Float(b)) => Expr::Float(a - b),
101
101
(Expr::Float(a), Expr::Int(b)) => Expr::Float(a - *b as Float),
102
-
(Expr::Int(a), Expr::Float(b)) => Expr::Int(a - *b as Int),
102
+
(Expr::Int(a), Expr::Float(b)) => Expr::Float(*a as Float - *b),
103
103
_ => self.clone(),
104
104
}
105
105
}
···
109
109
(Expr::Int(a), Expr::Int(b)) => Expr::Int(a * b),
110
110
(Expr::Float(a), Expr::Float(b)) => Expr::Float(a * b),
111
111
(Expr::Float(a), Expr::Int(b)) => Expr::Float(a * *b as Float),
112
-
(Expr::Int(a), Expr::Float(b)) => Expr::Int(a * *b as Int),
112
+
(Expr::Int(a), Expr::Float(b)) => Expr::Float(*a as Float * *b),
113
113
_ => self.clone(),
114
114
}
115
115
}
···
119
119
(Expr::Int(a), Expr::Int(b)) => Expr::Int(a / b),
120
120
(Expr::Float(a), Expr::Float(b)) => Expr::Float(a / b),
121
121
(Expr::Float(a), Expr::Int(b)) => Expr::Float(a / *b as Float),
122
-
(Expr::Int(a), Expr::Float(b)) => Expr::Int(a / *b as Int),
122
+
(Expr::Int(a), Expr::Float(b)) => Expr::Float(*a as Float / *b),
123
123
_ => self.clone(),
124
124
}
125
125
}