Files
Your NameandClaude Opus 5.5 7cf9727bcd Rename the language from Dino to Rex
Files use .rex, the command is rex, and the crate, runtime prefixes,
docs, editor files and examples all use the new name.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 13:51:23 +01:00

84 lines
2.6 KiB
Rexx

// 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
}