use std::cell::RefCell; use std::rc::Rc; use std::fmt::Write; use std::io; use itertools::Itertools; use crate::util::ScopeStack; use crate::reduced_ast::{BoundVars, ReducedAST, Stmt, Expr, Lit, Func, Alternative, Subpattern}; use crate::symbol_table::{SymbolSpec, Symbol, SymbolTable}; pub struct State<'a> { values: ScopeStack<'a, Rc, ValueEntry>, symbol_table_handle: Rc>, } macro_rules! builtin_binding { ($name:expr, $values:expr) => { $values.insert(Rc::new(format!($name)), ValueEntry::Binding { constant: true, val: Node::Expr(Expr::Func(Func::BuiltIn(Rc::new(format!($name))))) }); } } impl<'a> State<'a> { pub fn new(symbol_table_handle: Rc>) -> State<'a> { let mut values = ScopeStack::new(Some(format!("global"))); builtin_binding!("print", values); builtin_binding!("println", values); builtin_binding!("getline", values); State { values, symbol_table_handle } } pub fn debug_print(&self) -> String { format!("Values: {:?}", self.values) } fn new_frame(&'a self, items: &'a Vec, bound_vars: &BoundVars) -> State<'a> { let mut inner_state = State { values: self.values.new_scope(None), symbol_table_handle: self.symbol_table_handle.clone(), }; for (bound_var, val) in bound_vars.iter().zip(items.iter()) { if let Some(bv) = bound_var.as_ref() { inner_state.values.insert(bv.clone(), ValueEntry::Binding { constant: true, val: val.clone() }); } } inner_state } } #[derive(Debug, Clone)] enum Node { Expr(Expr), PrimObject { name: Rc, tag: usize, items: Vec, }, PrimTuple { items: Vec } } fn paren_wrapped_vec(terms: impl Iterator) -> String { let mut buf = String::new(); write!(buf, "(").unwrap(); for term in terms.map(|e| Some(e)).intersperse(None) { match term { Some(e) => write!(buf, "{}", e).unwrap(), None => write!(buf, ", ").unwrap(), }; } write!(buf, ")").unwrap(); buf } impl Node { fn to_repl(&self) -> String { match self { Node::Expr(e) => e.to_repl(), Node::PrimObject { name, items, .. } if items.len() == 0 => format!("{}", name), Node::PrimObject { name, items, .. } => format!("{}{}", name, paren_wrapped_vec(items.iter().map(|x| x.to_repl()))), Node::PrimTuple { items } => format!("{}", paren_wrapped_vec(items.iter().map(|x| x.to_repl()))), } } fn is_true(&self) -> bool { match self { Node::Expr(Expr::Lit(crate::reduced_ast::Lit::Bool(true))) => true, _ => false, } } } #[derive(Debug)] enum ValueEntry { Binding { constant: bool, val: /*FullyEvaluatedExpr*/ Node, //TODO make this use a subtype to represent fully evaluatedness } } type EvalResult = Result; impl Expr { fn to_node(self) -> Node { Node::Expr(self) } fn to_repl(&self) -> String { use self::Lit::*; use self::Func::*; match self { Expr::Lit(ref l) => match l { Nat(n) => format!("{}", n), Int(i) => format!("{}", i), Float(f) => format!("{}", f), Bool(b) => format!("{}", b), StringLit(s) => format!("\"{}\"", s), }, Expr::Func(f) => match f { BuiltIn(name) => format!("", name), UserDefined { name: None, .. } => format!(""), UserDefined { name: Some(name), .. } => format!("", name), }, Expr::Constructor { type_name, arity, .. } => { format!("", type_name, arity) }, Expr::Tuple(exprs) => paren_wrapped_vec(exprs.iter().map(|x| x.to_repl())), _ => format!("{:?}", self), } } fn replace_conditional_target_sigil(self, replacement: &Expr) -> Expr { use self::Expr::*; match self { ConditionalTargetSigilValue => replacement.clone(), Unit | Lit(_) | Func(_) | Val(_) | Constructor { .. } | CaseMatch { .. } | UnimplementedSigilValue => self, Tuple(exprs) => Tuple(exprs.into_iter().map(|e| e.replace_conditional_target_sigil(replacement)).collect()), Call { f, args } => { let new_args = args.into_iter().map(|e| e.replace_conditional_target_sigil(replacement)).collect(); Call { f, args: new_args } }, Conditional { .. } => panic!("Dunno if I need this, but if so implement"), Assign { .. } => panic!("I'm pretty sure I don't need this"), } } } impl<'a> State<'a> { pub fn evaluate(&mut self, ast: ReducedAST, repl: bool) -> Vec> { let mut acc = vec![]; // handle prebindings for statement in ast.0.iter() { self.prebinding(statement); } for statement in ast.0 { match self.statement(statement) { Ok(Some(ref output)) if repl => acc.push(Ok(output.to_repl())), Ok(_) => (), Err(error) => { acc.push(Err(format!("Runtime error: {}", error))); return acc; }, } } acc } fn prebinding(&mut self, stmt: &Stmt) { match stmt { Stmt::PreBinding { name, func } => { let v_entry = ValueEntry::Binding { constant: true, val: Node::Expr(Expr::Func(func.clone())) }; self.values.insert(name.clone(), v_entry); }, Stmt::Expr(_expr) => { //TODO have this support things like nested function defs }, _ => () } } fn statement(&mut self, stmt: Stmt) -> EvalResult> { match stmt { Stmt::Binding { name, constant, expr } => { let val = self.expression(Node::Expr(expr))?; self.values.insert(name.clone(), ValueEntry::Binding { constant, val }); Ok(None) }, Stmt::Expr(expr) => Ok(Some(self.expression(expr.to_node())?)), Stmt::PreBinding {..} | Stmt::Noop => Ok(None), } } fn block(&mut self, stmts: Vec) -> EvalResult { let mut ret = None; for stmt in stmts { ret = self.statement(stmt)?; } Ok(ret.unwrap_or(Node::Expr(Expr::Unit))) } fn expression(&mut self, node: Node) -> EvalResult { use self::Expr::*; match node { t @ Node::PrimTuple { .. } => Ok(t), obj @ Node::PrimObject { .. } => Ok(obj), Node::Expr(expr) => match expr { literal @ Lit(_) => Ok(Node::Expr(literal)), Call { box f, args } => self.call_expression(f, args), Val(v) => self.value(v), Constructor { arity, ref name, tag, .. } if arity == 0 => Ok(Node::PrimObject { name: name.clone(), tag, items: vec![] }), constructor @ Constructor { .. } => Ok(Node::Expr(constructor)), func @ Func(_) => Ok(Node::Expr(func)), Tuple(exprs) => { let nodes = exprs.into_iter().map(|expr| self.expression(Node::Expr(expr))).collect::,_>>()?; Ok(Node::PrimTuple { items: nodes }) }, Conditional { box cond, then_clause, else_clause } => self.conditional(cond, then_clause, else_clause), Assign { box val, box expr } => self.assign_expression(val, expr), Unit => Ok(Node::Expr(Unit)), CaseMatch { box cond, alternatives } => self.case_match_expression(cond, alternatives), ConditionalTargetSigilValue => Ok(Node::Expr(ConditionalTargetSigilValue)), UnimplementedSigilValue => Err(format!("Sigil value eval not implemented")), } } } fn call_expression(&mut self, f: Expr, args: Vec) -> EvalResult { use self::Expr::*; match self.expression(Node::Expr(f))? { Node::Expr(Constructor { type_name, name, tag, arity }) => self.apply_data_constructor(type_name, name, tag, arity, args), Node::Expr(Func(f)) => self.apply_function(f, args), other => return Err(format!("Tried to call {:?} which is not a function or data constructor", other)), } } fn apply_data_constructor(&mut self, _type_name: Rc, name: Rc, tag: usize, arity: usize, args: Vec) -> EvalResult { if arity != args.len() { return Err(format!("Data constructor {} requires {} arg(s)", name, arity)); } let evaled_args = args.into_iter().map(|expr| self.expression(Node::Expr(expr))).collect::,_>>()?; //let evaled_args = vec![]; Ok(Node::PrimObject { name: name.clone(), items: evaled_args, tag }) } fn apply_function(&mut self, f: Func, args: Vec) -> EvalResult { match f { Func::BuiltIn(sigil) => Ok(Node::Expr(self.apply_builtin(sigil, args)?)), Func::UserDefined { params, body, name } => { if params.len() != args.len() { return Err(format!("calling a {}-argument function with {} args", params.len(), args.len())) } let mut func_state = State { values: self.values.new_scope(name.map(|n| format!("{}", n))), symbol_table_handle: self.symbol_table_handle.clone(), }; for (param, val) in params.into_iter().zip(args.into_iter()) { let val = func_state.expression(Node::Expr(val))?; func_state.values.insert(param, ValueEntry::Binding { constant: true, val }); } // TODO figure out function return semantics func_state.block(body) } } } fn apply_builtin(&mut self, name: Rc, args: Vec) -> EvalResult { use self::Expr::*; use self::Lit::*; let evaled_args: Result, String> = args.into_iter().map(|arg| { match self.expression(Node::Expr(arg)) { Ok(Node::Expr(e)) => Ok(e), Ok(Node::PrimTuple { .. }) => Err(format!("Trying to apply a builtin to a tuple")), Ok(Node::PrimObject { .. }) => Err(format!("Trying to apply a builtin to a primitive object")), Err(e) => Err(e) } }).collect(); let evaled_args = evaled_args?; Ok(match (name.as_str(), evaled_args.as_slice()) { /* binops */ ("+", &[Lit(Nat(l)), Lit(Nat(r))]) => Lit(Nat(l + r)), ("++", &[Lit(StringLit(ref s1)), Lit(StringLit(ref s2))]) => Lit(StringLit(Rc::new(format!("{}{}", s1, s2)))), ("-", &[Lit(Nat(l)), Lit(Nat(r))]) => Lit(Nat(l - r)), ("*", &[Lit(Nat(l)), Lit(Nat(r))]) => Lit(Nat(l * r)), ("/", &[Lit(Nat(l)), Lit(Nat(r))]) => Lit(Float((l as f64)/ (r as f64))), ("quot", &[Lit(Nat(l)), Lit(Nat(r))]) => if r == 0 { return Err(format!("divide by zero")); } else { Lit(Nat(l / r)) }, ("%", &[Lit(Nat(l)), Lit(Nat(r))]) => Lit(Nat(l % r)), ("^", &[Lit(Nat(l)), Lit(Nat(r))]) => Lit(Nat(l ^ r)), ("&", &[Lit(Nat(l)), Lit(Nat(r))]) => Lit(Nat(l & r)), ("|", &[Lit(Nat(l)), Lit(Nat(r))]) => Lit(Nat(l | r)), /* comparisons */ ("==", &[Lit(Nat(l)), Lit(Nat(r))]) => Lit(Bool(l == r)), ("==", &[Lit(Int(l)), Lit(Int(r))]) => Lit(Bool(l == r)), ("==", &[Lit(Float(l)), Lit(Float(r))]) => Lit(Bool(l == r)), ("==", &[Lit(Bool(l)), Lit(Bool(r))]) => Lit(Bool(l == r)), ("==", &[Lit(StringLit(ref l)), Lit(StringLit(ref r))]) => Lit(Bool(l == r)), ("<", &[Lit(Nat(l)), Lit(Nat(r))]) => Lit(Bool(l < r)), ("<", &[Lit(Int(l)), Lit(Int(r))]) => Lit(Bool(l < r)), ("<", &[Lit(Float(l)), Lit(Float(r))]) => Lit(Bool(l < r)), ("<=", &[Lit(Nat(l)), Lit(Nat(r))]) => Lit(Bool(l <= r)), ("<=", &[Lit(Int(l)), Lit(Int(r))]) => Lit(Bool(l <= r)), ("<=", &[Lit(Float(l)), Lit(Float(r))]) => Lit(Bool(l <= r)), (">", &[Lit(Nat(l)), Lit(Nat(r))]) => Lit(Bool(l > r)), (">", &[Lit(Int(l)), Lit(Int(r))]) => Lit(Bool(l > r)), (">", &[Lit(Float(l)), Lit(Float(r))]) => Lit(Bool(l > r)), (">=", &[Lit(Nat(l)), Lit(Nat(r))]) => Lit(Bool(l >= r)), (">=", &[Lit(Int(l)), Lit(Int(r))]) => Lit(Bool(l >= r)), (">=", &[Lit(Float(l)), Lit(Float(r))]) => Lit(Bool(l >= r)), /* prefix ops */ ("!", &[Lit(Bool(true))]) => Lit(Bool(false)), ("!", &[Lit(Bool(false))]) => Lit(Bool(true)), ("-", &[Lit(Nat(n))]) => Lit(Int(-1*(n as i64))), ("-", &[Lit(Int(n))]) => Lit(Int(-1*(n as i64))), ("+", &[Lit(Int(n))]) => Lit(Int(n)), ("+", &[Lit(Nat(n))]) => Lit(Nat(n)), /* builtin functions */ ("print", &[ref anything]) => { print!("{}", anything.to_repl()); Expr::Unit }, ("println", &[ref anything]) => { println!("{}", anything.to_repl()); Expr::Unit }, ("getline", &[]) => { let mut buf = String::new(); io::stdin().read_line(&mut buf).expect("Error readling line in 'getline'"); Lit(StringLit(Rc::new(buf.trim().to_string()))) }, (x, args) => return Err(format!("bad or unimplemented builtin {:?} | {:?}", x, args)), }) } fn conditional(&mut self, cond: Expr, then_clause: Vec, else_clause: Vec) -> EvalResult { let cond = self.expression(Node::Expr(cond))?; Ok(match cond { Node::Expr(Expr::Lit(Lit::Bool(true))) => self.block(then_clause)?, Node::Expr(Expr::Lit(Lit::Bool(false))) => self.block(else_clause)?, _ => return Err(format!("Conditional with non-boolean condition")) }) } fn assign_expression(&mut self, val: Expr, expr: Expr) -> EvalResult { let name = match val { Expr::Val(name) => name, _ => return Err(format!("Trying to assign to a non-value")), }; let constant = match self.values.lookup(&name) { None => return Err(format!("Constant {} is undefined", name)), Some(ValueEntry::Binding { constant, .. }) => constant.clone(), }; if constant { return Err(format!("trying to update {}, a non-mutable binding", name)); } let val = self.expression(Node::Expr(expr))?; self.values.insert(name.clone(), ValueEntry::Binding { constant: false, val }); Ok(Node::Expr(Expr::Unit)) } fn guard_passes(&mut self, guard: &Option, cond: &Node) -> EvalResult { if let Some(ref guard_expr) = guard { let guard_expr = match cond { Node::Expr(ref e) => guard_expr.clone().replace_conditional_target_sigil(e), _ => guard_expr.clone() }; Ok(self.expression(guard_expr.to_node())?.is_true()) } else { Ok(true) } } fn case_match_expression(&mut self, cond: Expr, alternatives: Vec) -> EvalResult { //TODO need to handle recursive subpatterns let all_subpatterns_pass = |state: &mut State, subpatterns: &Vec>, items: &Vec| -> EvalResult { if subpatterns.len() == 0 { return Ok(true) } if items.len() != subpatterns.len() { return Err(format!("Subpattern length isn't correct items {} subpatterns {}", items.len(), subpatterns.len())); } for (maybe_subp, cond) in subpatterns.iter().zip(items.iter()) { if let Some(subp) = maybe_subp { if !state.guard_passes(&subp.guard, &cond)? { return Ok(false) } } } Ok(true) }; let cond = self.expression(Node::Expr(cond))?; for alt in alternatives { // no matter what type of condition we have, ignore alternative if the guard evaluates false if !self.guard_passes(&alt.matchable.guard, &cond)? { continue; } match cond { Node::PrimObject { ref tag, ref items, .. } => { if alt.matchable.tag.map(|t| t == *tag).unwrap_or(true) { let mut inner_state = self.new_frame(items, &alt.matchable.bound_vars); if all_subpatterns_pass(&mut inner_state, &alt.matchable.subpatterns, items)? { return inner_state.block(alt.item); } else { continue; } } }, Node::PrimTuple { ref items } => { let mut inner_state = self.new_frame(items, &alt.matchable.bound_vars); if all_subpatterns_pass(&mut inner_state, &alt.matchable.subpatterns, items)? { return inner_state.block(alt.item); } else { continue; } }, Node::Expr(ref _e) => { if let None = alt.matchable.tag { return self.block(alt.item) } } } } Err(format!("{:?} failed pattern match", cond)) } //TODO if I don't need to lookup by name here... fn value(&mut self, name: Rc) -> EvalResult { use self::ValueEntry::*; use self::Func::*; //TODO add a layer of indirection here to talk to the symbol table first, and only then look up //in the values table let symbol_table = self.symbol_table_handle.borrow(); let value = symbol_table.lookup_by_name(&name); Ok(match value { Some(Symbol { name, spec, .. }) => match spec { //TODO I'll need this type_name later to do a table lookup SymbolSpec::DataConstructor { type_name: _type_name, type_args, .. } => { if type_args.len() == 0 { Node::PrimObject { name: name.clone(), tag: 0, items: vec![] } } else { return Err(format!("This data constructor thing not done")) } }, SymbolSpec::Func(_) => match self.values.lookup(&name) { Some(Binding { val: Node::Expr(Expr::Func(UserDefined { name, params, body })), .. }) => { Node::Expr(Expr::Func(UserDefined { name: name.clone(), params: params.clone(), body: body.clone() })) }, _ => unreachable!(), }, SymbolSpec::RecordConstructor { .. } => return Err(format!("This shouldn't be a record!")), SymbolSpec::Binding => match self.values.lookup(&name) { Some(Binding { val, .. }) => val.clone(), None => return Err(format!("Symbol {} exists in symbol table but not in evaluator table", name)) } }, //TODO ideally this should be returning a runtime error if this is ever None, but it's not //handling all bindings correctly yet //None => return Err(format!("Couldn't find value {}", name)), None => match self.values.lookup(&name) { Some(Binding { val, .. }) => val.clone(), None => return Err(format!("Couldn't find value {}", name)), } }) } } #[cfg(test)] mod eval_tests { use std::cell::RefCell; use std::rc::Rc; use crate::symbol_table::SymbolTable; use crate::eval::State; fn evaluate_all_outputs(input: &str) -> Vec> { let symbol_table = Rc::new(RefCell::new(SymbolTable::new())); let mut state = State::new(symbol_table); let ast = crate::util::quick_ast(input); state.symbol_table_handle.borrow_mut().add_top_level_symbols(&ast).unwrap(); let reduced = ast.reduce(&state.symbol_table_handle.borrow()); let all_output = state.evaluate(reduced, true); all_output } macro_rules! test_in_fresh_env { ($string:expr, $correct:expr) => { { let all_output = evaluate_all_outputs($string); let ref output = all_output.last().unwrap(); assert_eq!(**output, Ok($correct.to_string())); } } } #[test] fn test_basic_eval() { test_in_fresh_env!("1 + 2", "3"); test_in_fresh_env!("let mut a = 1; a = 2", "Unit"); /* test_in_fresh_env!("let mut a = 1; a = 2; a", "2"); test_in_fresh_env!(r#"("a", 1 + 2)"#, r#"("a", 3)"#); */ } #[test] fn function_eval() { test_in_fresh_env!("fn oi(x) { x + 1 }; oi(4)", "5"); test_in_fresh_env!("fn oi(x) { x + 1 }; oi(1+2)", "4"); } #[test] fn scopes() { let scope_ok = r#" let a = 20 fn haha() { let a = 10 a } haha() "#; test_in_fresh_env!(scope_ok, "10"); let scope_ok = r#" let a = 20 fn haha() { let a = 10 a } a "#; test_in_fresh_env!(scope_ok, "20"); } #[test] fn if_is_patterns() { let source = r#" type Option = Some(T) | None let x = Some(9); if x is Some(q) then { q } else { 0 }"#; test_in_fresh_env!(source, "9"); let source = r#" type Option = Some(T) | None let x = None; if x is Some(q) then { q } else { 0 }"#; test_in_fresh_env!(source, "0"); } #[test] fn full_if_matching() { let source = r#" type Option = Some(T) | None let a = None if a { is None -> 4, is Some(x) -> x } "#; test_in_fresh_env!(source, "4"); let source = r#" type Option = Some(T) | None let a = Some(99) if a { is None -> 4, is Some(x) -> x } "#; test_in_fresh_env!(source, "99"); let source = r#" let a = 10 if a { is 10 -> "x", is 4 -> "y" } "#; test_in_fresh_env!(source, "\"x\""); let source = r#" let a = 10 if a { is 15 -> "x", is 10 -> "y" } "#; test_in_fresh_env!(source, "\"y\""); } #[test] fn string_pattern() { let source = r#" let a = "foo" if a { is "foo" -> "x", is _ -> "y" } "#; test_in_fresh_env!(source, "\"x\""); } #[test] fn boolean_pattern() { let source = r#" let a = true if a { is true -> "x", is false -> "y" } "#; test_in_fresh_env!(source, "\"x\""); } #[test] fn boolean_pattern_2() { let source = r#" let a = false if a { is true -> "x", is false -> "y" } "#; test_in_fresh_env!(source, "\"y\""); } #[test] fn ignore_pattern() { let source = r#" type Option = Some(T) | None if Some(10) { is _ -> "hella" } "#; test_in_fresh_env!(source, "\"hella\""); } #[test] fn tuple_pattern() { let source = r#" if (1, 2) { is (1, x) -> x, is _ -> 99 } "#; test_in_fresh_env!(source, 2); } #[test] fn tuple_pattern_2() { let source = r#" if (1, 2) { is (10, x) -> x, is (y, x) -> x + y } "#; test_in_fresh_env!(source, 3); } #[test] fn tuple_pattern_3() { let source = r#" if (1, 5) { is (10, x) -> x, is (1, x) -> x } "#; test_in_fresh_env!(source, 5); } #[test] fn tuple_pattern_4() { let source = r#" if (1, 5) { is (10, x) -> x, is (1, x) -> x, } "#; test_in_fresh_env!(source, 5); } #[test] fn prim_obj_pattern() { let source = r#" type Stuff = Mulch(Nat) | Jugs(Nat, String) | Mardok let a = Mulch(20) let b = Jugs(1, "haha") let c = Mardok let x = if a { is Mulch(20) -> "x", is _ -> "ERR" } let y = if b { is Mulch(n) -> "ERR", is Jugs(2, _) -> "ERR", is Jugs(1, s) -> s, is _ -> "ERR", } let z = if c { is Jugs(_, _) -> "ERR", is Mardok -> "NIGH", is _ -> "ERR", } (x, y, z) "#; test_in_fresh_env!(source, r#"("x", "haha", "NIGH")"#); } #[test] fn basic_lambda_syntax() { let source = r#" let q = \(x, y) { x * y } let x = q(5,2) let y = \(m, n, o) { m + n + o }(1,2,3) (x, y) "#; test_in_fresh_env!(source, r"(10, 6)"); } #[test] fn lambda_syntax_2() { let source = r#" fn milta() { \(x) { x + 33 } } milta()(10) "#; test_in_fresh_env!(source, "43"); } }