tool for me to use if i drop nixos
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

fix certain evaluation problems

IamPyu 753f36f1 86062434

+53 -26
+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
··· 81 81 .unwrap(); 82 82 engine.eval_chunk(&chunk).unwrap(); 83 83 } 84 + 85 + #[test] 86 + fn src() { 87 + let engine = Engine::new(); 88 + 89 + let chunk = Chunk::from_source(include_str!("./tests/hello.dmx")).unwrap(); 90 + engine.eval_chunk(&chunk).unwrap(); 91 + } 84 92 }
+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
··· 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
··· 1 + ; vim:ft=scheme 2 + 3 + (debug "hello") 4 + (debug (let { 5 + name "jeff", 6 + gtr 54, 7 + pi 3.1415926535, 8 + func (lambda (x) (* x 2)), 9 + } (list (func pi) gtr name pi)))
+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 }