// Evaluates a parsed calculation. Variables and functions live in `Scope`. import ast import math pub struct Builtin { pub name: string pub arity: int pub run: func([]float): float } pub struct Scope { variables: map[string, float] builtins: map[string, Builtin] pub func set(name: string, v: float) { variables[name] = v } pub func eval(n: ast.Node): (float, error) { match n { Num(v) => return v, nil Var(name) => { var v = variables.get(name) if v == nil { return 0.0, error("unknown variable `{name}`") } return v, nil } Neg(inner) => { var x = eval(inner[0])? return -x, nil } Assign(name, value) => { var x = eval(value[0])? set(name, x) return x, nil } Bin(op, sides) => { var a = eval(sides[0])? var b = eval(sides[1])? return apply(op, a, b) } Call(name, args) => { if !builtins.has(name) { return 0.0, error("unknown function `{name}`") } var b = builtins[name] if args.len() != b.arity { return 0.0, error("`{name}` takes {b.arity} argument(s), but {args.len()} given") } var vals: []float for a in args { vals.push(eval(a)?) } return b.run(vals), nil } } } func apply(op: string, a, b: float): (float, error) { match op { "+" => return a + b, nil "-" => return a - b, nil "*" => return a * b, nil "/" => { if b == 0.0 { return 0.0, error("division by zero") } return a / b, nil } "%" => { if b == 0.0 { return 0.0, error("division by zero") } return a - b * math.floor(a / b), nil } "^" => return math.pow(a, b), nil _ => return 0.0, error("unknown operator `{op}`") } } } pub func new_scope(): Scope { var s = Scope{} s.builtins["sqrt"] = Builtin{"sqrt", 1, a => math.sqrt(a[0])} s.builtins["abs"] = Builtin{"abs", 1, a => math.abs(a[0])} s.builtins["max"] = Builtin{"max", 2, a => math.max(a[0], a[1])} s.builtins["min"] = Builtin{"min", 2, a => math.min(a[0], a[1])} s.builtins["sum"] = Builtin{"sum", 3, a => a[0] + a[1] + a[2]} s.set("pi", math.PI) s.set("e", math.E) return s }