use fusevm::vm::{VMResult, VM};
use fusevm::{ChunkBuilder, Op, Value};
use std::cell::RefCell;
#[derive(Debug, Clone, Copy)]
pub enum BinOp {
Add,
Sub,
Mul,
Div,
Mod,
Eq,
Ne,
Lt,
Le,
Gt,
Ge,
And,
Or,
}
#[derive(Debug, Clone)]
pub enum Expr {
Num(f64),
Var,
Field(String),
Control(String),
Str(String),
Match(Box<Expr>),
InSet(String, Box<Expr>),
Neg(Box<Expr>),
Not(Box<Expr>),
Call(String, Vec<Expr>),
InList(Box<Expr>, Vec<Expr>),
InRange(Box<Expr>, Box<Expr>, Box<Expr>),
Cond(Box<Expr>, Box<Expr>, Box<Expr>),
Bin(BinOp, Box<Expr>, Box<Expr>),
}
pub fn parse(src: &str) -> Result<Expr, String> {
let mut p = Parser {
c: src.chars().collect(),
i: 0,
depth: 0,
};
let e = p.ternary()?;
if p.peek().is_some() {
return Err(format!("calc: unexpected `{}`", p.c[p.i]));
}
Ok(e)
}
pub fn eval(e: &Expr, x: f64) -> Result<f64, String> {
eval_ctx(e, x, &|_| f64::NAN)
}
pub fn control_names(e: &Expr, out: &mut Vec<String>) {
match e {
Expr::Control(n) => out.push(n.clone()),
Expr::Num(_) | Expr::Var | Expr::Field(_) | Expr::Str(_) => {}
Expr::Neg(a) | Expr::Not(a) | Expr::Match(a) | Expr::InSet(_, a) => control_names(a, out),
Expr::Call(_, items) => items.iter().for_each(|it| control_names(it, out)),
Expr::InList(l, items) => {
control_names(l, out);
items.iter().for_each(|it| control_names(it, out));
}
Expr::InRange(l, lo, hi) => {
control_names(l, out);
control_names(lo, out);
control_names(hi, out);
}
Expr::Cond(a, b, c) => {
control_names(a, out);
control_names(b, out);
control_names(c, out);
}
Expr::Bin(_, a, b) => {
control_names(a, out);
control_names(b, out);
}
}
}
pub fn control_names_typed(e: &Expr, num: &mut Vec<String>, strv: &mut Vec<String>) {
match e {
Expr::Control(n) => num.push(n.clone()),
Expr::Match(inner) | Expr::InSet(_, inner) => {
if let Expr::Control(n) = inner.as_ref() {
strv.push(n.clone());
} else {
control_names_typed(inner, num, strv);
}
}
Expr::Num(_) | Expr::Var | Expr::Field(_) | Expr::Str(_) => {}
Expr::Neg(a) | Expr::Not(a) => control_names_typed(a, num, strv),
Expr::Call(_, items) => items
.iter()
.for_each(|it| control_names_typed(it, num, strv)),
Expr::InList(l, items) => {
control_names_typed(l, num, strv);
items
.iter()
.for_each(|it| control_names_typed(it, num, strv));
}
Expr::InRange(l, lo, hi) => {
control_names_typed(l, num, strv);
control_names_typed(lo, num, strv);
control_names_typed(hi, num, strv);
}
Expr::Cond(a, b, c) => {
control_names_typed(a, num, strv);
control_names_typed(b, num, strv);
control_names_typed(c, num, strv);
}
Expr::Bin(_, a, b) => {
control_names_typed(a, num, strv);
control_names_typed(b, num, strv);
}
}
}
pub fn expr_has_str(e: &Expr) -> bool {
match e {
Expr::Match(_) | Expr::InSet(..) | Expr::Str(_) => true,
Expr::Num(_) | Expr::Var | Expr::Field(_) | Expr::Control(_) => false,
Expr::Neg(a) | Expr::Not(a) => expr_has_str(a),
Expr::Call(_, items) => items.iter().any(expr_has_str),
Expr::InList(l, items) => expr_has_str(l) || items.iter().any(expr_has_str),
Expr::InRange(l, lo, hi) => expr_has_str(l) || expr_has_str(lo) || expr_has_str(hi),
Expr::Cond(a, b, c) => expr_has_str(a) || expr_has_str(b) || expr_has_str(c),
Expr::Bin(_, a, b) => expr_has_str(a) || expr_has_str(b),
}
}
pub fn prefix_controls(e: &mut Expr, ns: &str) {
match e {
Expr::Control(n) => *n = format!("{ns}.{n}"),
Expr::Num(_) | Expr::Var | Expr::Field(_) | Expr::Str(_) => {}
Expr::Neg(a) | Expr::Not(a) | Expr::Match(a) | Expr::InSet(_, a) => prefix_controls(a, ns),
Expr::Call(_, items) => items.iter_mut().for_each(|it| prefix_controls(it, ns)),
Expr::InList(l, items) => {
prefix_controls(l, ns);
items.iter_mut().for_each(|it| prefix_controls(it, ns));
}
Expr::InRange(l, lo, hi) => {
prefix_controls(l, ns);
prefix_controls(lo, ns);
prefix_controls(hi, ns);
}
Expr::Cond(a, b, c) => {
prefix_controls(a, ns);
prefix_controls(b, ns);
prefix_controls(c, ns);
}
Expr::Bin(_, a, b) => {
prefix_controls(a, ns);
prefix_controls(b, ns);
}
}
}
pub fn substitute_controls(
e: &Expr,
num: &dyn Fn(&str) -> Option<f64>,
strv: &dyn Fn(&str) -> Option<String>,
) -> Expr {
let sub = |b: &Expr| Box::new(substitute_controls(b, num, strv));
let sub_str = |b: &Expr| -> Box<Expr> {
match b {
Expr::Control(n) => Box::new(Expr::Str(strv(n).unwrap_or_default())),
other => Box::new(substitute_controls(other, num, strv)),
}
};
match e {
Expr::Control(n) => match num(n) {
Some(v) => Expr::Num(v),
None => Expr::Control(n.clone()),
},
Expr::Match(inner) => Expr::Match(sub_str(inner)),
Expr::InSet(field, inner) => Expr::InSet(field.clone(), sub_str(inner)),
Expr::Num(_) | Expr::Var | Expr::Field(_) | Expr::Str(_) => e.clone(),
Expr::Call(name, items) => Expr::Call(
name.clone(),
items
.iter()
.map(|it| substitute_controls(it, num, strv))
.collect(),
),
Expr::Neg(a) => Expr::Neg(sub(a)),
Expr::Not(a) => Expr::Not(sub(a)),
Expr::InList(l, items) => Expr::InList(
sub(l),
items
.iter()
.map(|it| substitute_controls(it, num, strv))
.collect(),
),
Expr::InRange(l, lo, hi) => Expr::InRange(sub(l), sub(lo), sub(hi)),
Expr::Cond(a, b, c) => Expr::Cond(sub(a), sub(b), sub(c)),
Expr::Bin(op, a, b) => Expr::Bin(*op, sub(a), sub(b)),
}
}
fn arm_tiers(vm: &mut VM) {
vm.enable_tracing_jit();
}
pub fn eval_ctx(e: &Expr, x: f64, resolve: &dyn Fn(&str) -> f64) -> Result<f64, String> {
let mut b = ChunkBuilder::new();
emit(e, x, resolve, &mut b);
with_pooled_vm(b.build(), |vm| match vm.run() {
VMResult::Ok(v) => Ok(v.to_float()),
VMResult::Halted => Ok(vm.peek().to_float()),
VMResult::Error(err) => Err(err),
})
}
thread_local! {
static VM_POOL: RefCell<fusevm::vm::VMPool> = RefCell::new(fusevm::vm::VMPool::new());
}
fn with_pooled_vm<T>(chunk: fusevm::Chunk, f: impl FnOnce(&mut VM) -> T) -> T {
VM_POOL.with(|p| {
let mut vm = p.borrow_mut().acquire(chunk);
arm_tiers(&mut vm);
let r = f(&mut vm);
p.borrow_mut().release(vm);
r
})
}
pub fn chunk_of(e: &Expr, x: f64, resolve: &dyn Fn(&str) -> f64) -> fusevm::Chunk {
let mut b = ChunkBuilder::new();
emit(e, x, resolve, &mut b);
b.build()
}
pub fn eval_pred(e: &Expr, x: f64) -> Result<bool, String> {
eval_pred_ctx(e, x, &|_| f64::NAN)
}
pub fn eval_pred_ctx(e: &Expr, x: f64, resolve: &dyn Fn(&str) -> f64) -> Result<bool, String> {
let mut b = ChunkBuilder::new();
emit(e, x, resolve, &mut b);
with_pooled_vm(b.build(), |vm| match vm.run() {
VMResult::Ok(v) => Ok(v.is_truthy()),
VMResult::Halted => Ok(vm.peek().is_truthy()),
VMResult::Error(err) => Err(err),
})
}
fn eval_call(name: &str, args: &[Expr], x: f64, resolve: &dyn Fn(&str) -> f64) -> f64 {
if !fusevm::ffi::is_registered(name) {
return f64::NAN;
}
let vals: Vec<Value> = args
.iter()
.map(|a| Value::float(eval_ctx(a, x, resolve).unwrap_or(f64::NAN)))
.collect();
match fusevm::ffi::try_call(name, &vals) {
Some(Ok(v)) => v.to_float(),
_ => f64::NAN,
}
}
fn emit(e: &Expr, x: f64, resolve: &dyn Fn(&str) -> f64, b: &mut ChunkBuilder) {
match e {
Expr::Num(n) => {
b.emit(Op::LoadFloat(*n), 0);
}
Expr::Var => {
b.emit(Op::LoadFloat(x), 0);
}
Expr::Field(name) => {
b.emit(Op::LoadFloat(resolve(name)), 0);
}
Expr::Control(_) => {
b.emit(Op::LoadFloat(f64::NAN), 0);
}
Expr::Str(_) | Expr::Match(_) | Expr::InSet(..) => {
b.emit(Op::LoadFloat(0.0), 0);
}
Expr::Call(name, args) => {
b.emit(Op::LoadFloat(eval_call(name, args, x, resolve)), 0);
}
Expr::Neg(a) => {
emit(a, x, resolve, b);
b.emit(Op::Negate, 0);
}
Expr::Not(a) => {
emit(a, x, resolve, b);
b.emit(Op::LoadFloat(0.0), 0);
b.emit(Op::NumEq, 0);
}
Expr::InList(left, items) => {
if items.is_empty() {
b.emit(Op::LoadFloat(0.0), 0);
} else {
for (k, it) in items.iter().enumerate() {
emit(left, x, resolve, b);
emit(it, x, resolve, b);
b.emit(Op::NumEq, 0);
if k > 0 {
b.emit(Op::Add, 0);
}
}
if items.len() > 1 {
emit_normalize_bool(b);
}
}
}
Expr::InRange(left, lo, hi) => {
emit(left, x, resolve, b);
emit(lo, x, resolve, b);
b.emit(Op::NumGe, 0);
emit(left, x, resolve, b);
emit(hi, x, resolve, b);
b.emit(Op::NumLe, 0);
b.emit(Op::Mul, 0);
}
Expr::Cond(c, t, e2) => {
emit(c, x, resolve, b);
let jf = b.emit(Op::JumpIfFalse(0), 0);
emit(t, x, resolve, b);
let jend = b.emit(Op::Jump(0), 0);
let else_pos = b.current_pos();
b.patch_jump(jf, else_pos);
emit(e2, x, resolve, b);
let end_pos = b.current_pos();
b.patch_jump(jend, end_pos);
}
Expr::Bin(BinOp::And, a, c) => {
emit_bool(a, x, resolve, b);
emit_bool(c, x, resolve, b);
b.emit(Op::Mul, 0);
}
Expr::Bin(BinOp::Or, a, c) => {
emit_bool(a, x, resolve, b);
emit_bool(c, x, resolve, b);
b.emit(Op::Add, 0);
emit_normalize_bool(b);
}
Expr::Bin(op, a, c) => {
emit(a, x, resolve, b);
emit(c, x, resolve, b);
b.emit(
match op {
BinOp::Add => Op::Add,
BinOp::Sub => Op::Sub,
BinOp::Mul => Op::Mul,
BinOp::Div => Op::Div,
BinOp::Mod => Op::Mod,
BinOp::Eq => Op::NumEq,
BinOp::Ne => Op::NumNe,
BinOp::Lt => Op::NumLt,
BinOp::Le => Op::NumLe,
BinOp::Gt => Op::NumGt,
BinOp::Ge => Op::NumGe,
BinOp::And | BinOp::Or => unreachable!("handled above"),
},
0,
);
}
}
}
fn emit_bool(e: &Expr, x: f64, resolve: &dyn Fn(&str) -> f64, b: &mut ChunkBuilder) {
emit(e, x, resolve, b);
emit_normalize_bool(b);
}
fn emit_normalize_bool(b: &mut ChunkBuilder) {
b.emit(Op::LoadFloat(0.0), 0);
b.emit(Op::NumNe, 0);
}
struct Parser {
c: Vec<char>,
i: usize,
depth: usize,
}
const MAX_EXPR_DEPTH: usize = 128;
impl Parser {
fn peek(&mut self) -> Option<char> {
while self.i < self.c.len() && self.c[self.i].is_whitespace() {
self.i += 1;
}
self.c.get(self.i).copied()
}
fn ternary(&mut self) -> Result<Expr, String> {
let cond = self.or_expr()?;
if self.peek() == Some('?') {
self.i += 1;
let then = self.ternary()?;
if self.peek() != Some(':') {
return Err("calc: expected `:` in `?:`".into());
}
self.i += 1;
let els = self.ternary()?;
return Ok(Expr::Cond(Box::new(cond), Box::new(then), Box::new(els)));
}
Ok(cond)
}
fn or_expr(&mut self) -> Result<Expr, String> {
let mut left = self.and_expr()?;
while self.match_kw("or") {
let right = self.and_expr()?;
left = Expr::Bin(BinOp::Or, Box::new(left), Box::new(right));
}
Ok(left)
}
fn and_expr(&mut self) -> Result<Expr, String> {
let mut left = self.not_expr()?;
while self.match_kw("and") {
let right = self.not_expr()?;
left = Expr::Bin(BinOp::And, Box::new(left), Box::new(right));
}
Ok(left)
}
fn not_expr(&mut self) -> Result<Expr, String> {
if self.match_kw("not") {
self.deepen()?;
let inner = self.not_expr();
self.depth -= 1;
return Ok(Expr::Not(Box::new(inner?)));
}
self.comparison()
}
fn match_kw(&mut self, kw: &str) -> bool {
let save = self.i;
while self.i < self.c.len() && self.c[self.i].is_whitespace() {
self.i += 1;
}
let start = self.i;
let kwc: Vec<char> = kw.chars().collect();
let end = start + kwc.len();
let boundary_ok =
end >= self.c.len() || !(self.c[end].is_ascii_alphanumeric() || self.c[end] == '_');
if end <= self.c.len() && self.c[start..end] == kwc[..] && boundary_ok {
self.i = end;
true
} else {
self.i = save;
false
}
}
fn comparison(&mut self) -> Result<Expr, String> {
let mut left = self.additive()?;
if self.match_kw("in") {
return self.in_list(left);
}
while let Some(op) = self.cmp_op() {
let right = self.additive()?;
left = Expr::Bin(op, Box::new(left), Box::new(right));
}
Ok(left)
}
fn control_ref(&mut self) -> Result<Expr, String> {
if self.peek() != Some('.') {
return Err("expected a control ref `.name`".into());
}
self.i += 1; let name = self.dotted_ident();
if name.is_empty() {
return Err("expected a control name after `.`".into());
}
Ok(Expr::Control(name))
}
fn in_list(&mut self, left: Expr) -> Result<Expr, String> {
if self.peek() == Some('.')
&& matches!(self.c.get(self.i + 1), Some(c) if c.is_ascii_alphabetic() || *c == '_')
{
let field = match &left {
Expr::Field(n) => n.clone(),
Expr::Var => "x".to_string(),
_ => return Err("in .set: left side must be a field".into()),
};
let ctrl = self.control_ref()?;
return Ok(Expr::InSet(field, Box::new(ctrl)));
}
if self.peek() != Some('[') {
let lo = self.additive()?;
if !(self.peek() == Some('.') && self.c.get(self.i + 1) == Some(&'.')) {
return Err("in: expected `[list]` or `lo..hi`".into());
}
self.i += 2;
let hi = self.additive()?;
return Ok(Expr::InRange(Box::new(left), Box::new(lo), Box::new(hi)));
}
self.i += 1;
let mut items = Vec::new();
loop {
if self.peek() == Some(']') {
self.i += 1;
break;
}
items.push(self.additive()?);
match self.peek() {
Some(',') => self.i += 1,
Some(']') => {
self.i += 1;
break;
}
_ => return Err("in: expected `,` or `]`".into()),
}
}
Ok(Expr::InList(Box::new(left), items))
}
fn cmp_op(&mut self) -> Option<BinOp> {
let c = self.peek()?;
if !matches!(c, '<' | '>' | '=' | '!') {
return None;
}
let next = self.c.get(self.i + 1).copied();
let (op, len) = match (c, next) {
('<', Some('=')) => (BinOp::Le, 2),
('<', _) => (BinOp::Lt, 1),
('>', Some('=')) => (BinOp::Ge, 2),
('>', _) => (BinOp::Gt, 1),
('=', Some('=')) => (BinOp::Eq, 2),
('!', Some('=')) => (BinOp::Ne, 2),
_ => return None,
};
self.i += len;
Some(op)
}
fn additive(&mut self) -> Result<Expr, String> {
let mut left = self.multiplicative()?;
while let Some(c) = self.peek() {
let op = match c {
'+' => BinOp::Add,
'-' => BinOp::Sub,
_ => break,
};
self.i += 1;
let right = self.multiplicative()?;
left = Expr::Bin(op, Box::new(left), Box::new(right));
}
Ok(left)
}
fn multiplicative(&mut self) -> Result<Expr, String> {
let mut left = self.unary()?;
while let Some(c) = self.peek() {
let op = match c {
'*' => BinOp::Mul,
'/' => BinOp::Div,
'%' => BinOp::Mod,
_ => break,
};
self.i += 1;
let right = self.unary()?;
left = Expr::Bin(op, Box::new(left), Box::new(right));
}
Ok(left)
}
fn unary(&mut self) -> Result<Expr, String> {
if self.peek() == Some('-') {
self.i += 1;
self.deepen()?;
let inner = self.unary();
self.depth -= 1;
return Ok(Expr::Neg(Box::new(inner?)));
}
self.primary()
}
fn deepen(&mut self) -> Result<(), String> {
self.depth += 1;
if self.depth > MAX_EXPR_DEPTH {
self.depth -= 1;
return Err("calc: expression too deeply nested".into());
}
Ok(())
}
fn primary(&mut self) -> Result<Expr, String> {
self.deepen()?;
let r = self.primary_inner();
self.depth -= 1;
r
}
fn primary_inner(&mut self) -> Result<Expr, String> {
match self.peek() {
Some('(') => {
self.i += 1;
let e = self.ternary()?;
if self.peek() != Some(')') {
return Err("calc: expected `)`".into());
}
self.i += 1;
Ok(e)
}
Some(c) if c.is_ascii_alphabetic() || c == '_' => {
let name = self.ident();
if name == "match" && self.peek() == Some('(') {
self.i += 1; let inner = self.control_ref()?;
if self.peek() != Some(')') {
return Err("match: expected `)`".into());
}
self.i += 1;
return Ok(Expr::Match(Box::new(inner)));
}
if self.peek() == Some('(') {
return self.call(name);
}
Ok(if name == "x" {
Expr::Var
} else {
Expr::Field(name)
})
}
Some('.') if matches!(self.c.get(self.i + 1), Some(c) if c.is_ascii_alphabetic() || *c == '_') =>
{
self.i += 1; Ok(Expr::Control(self.dotted_ident()))
}
Some(c) if c.is_ascii_digit() || c == '.' => self.number(),
Some('"') => {
self.i += 1; let mut s = String::new();
while let Some(&c) = self.c.get(self.i) {
match c {
'"' => {
self.i += 1;
return Ok(Expr::Str(s));
}
'\\' if self.i + 1 < self.c.len() => {
s.push(match self.c[self.i + 1] {
'n' => '\n',
't' => '\t',
o => o,
});
self.i += 2;
}
_ => {
s.push(c);
self.i += 1;
}
}
}
Err("calc: unterminated string literal".into())
}
Some(c) => Err(format!("calc: unexpected `{c}`")),
None => Err("calc: unexpected end of expression".into()),
}
}
fn ident(&mut self) -> String {
let start = self.i;
while self.i < self.c.len()
&& (self.c[self.i].is_ascii_alphanumeric() || self.c[self.i] == '_')
{
self.i += 1;
}
self.c[start..self.i].iter().collect()
}
fn dotted_ident(&mut self) -> String {
let mut name = self.ident();
while self.i < self.c.len()
&& self.c[self.i] == '.'
&& matches!(self.c.get(self.i + 1), Some(c) if c.is_ascii_alphabetic() || *c == '_')
{
self.i += 1; name.push('.');
name.push_str(&self.ident());
}
name
}
fn call(&mut self, name: String) -> Result<Expr, String> {
self.i += 1; let mut args = Vec::new();
if self.peek() != Some(')') {
loop {
args.push(self.ternary()?);
match self.peek() {
Some(',') => self.i += 1,
Some(')') => break,
_ => return Err(format!("calc: expected `,` or `)` in call to `{name}`")),
}
}
}
self.i += 1; Ok(Expr::Call(name, args))
}
fn number(&mut self) -> Result<Expr, String> {
let start = self.i;
while self.i < self.c.len() && self.c[self.i].is_ascii_digit() {
self.i += 1;
}
if self.i < self.c.len()
&& self.c[self.i] == '.'
&& matches!(self.c.get(self.i + 1), Some(d) if d.is_ascii_digit())
{
self.i += 1;
while self.i < self.c.len() && self.c[self.i].is_ascii_digit() {
self.i += 1;
}
}
if matches!(self.c.get(self.i), Some('e' | 'E')) {
let after_sign = match self.c.get(self.i + 1) {
Some('+' | '-') => self.i + 2,
_ => self.i + 1,
};
if matches!(self.c.get(after_sign), Some(d) if d.is_ascii_digit()) {
self.i = after_sign;
while self.i < self.c.len() && self.c[self.i].is_ascii_digit() {
self.i += 1;
}
}
}
let s: String = self.c[start..self.i].iter().collect();
s.parse::<f64>()
.map(Expr::Num)
.map_err(|_| format!("calc: bad number `{s}`"))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn dotted_control_name_parses_whole() {
let e = parse(".ps.sel").unwrap();
let mut names = Vec::new();
control_names(&e, &mut names);
assert_eq!(names, vec!["ps.sel".to_string()]);
}
#[test]
fn dotted_control_substitutes_and_evals() {
let e = parse(".k.v * 2").unwrap();
let num = |n: &str| if n == "k.v" { Some(21.0) } else { None };
let strv = |_: &str| None;
let sub = substitute_controls(&e, &num, &strv);
assert_eq!(eval(&sub, 0.0).unwrap(), 42.0);
}
#[test]
fn boolean_nodes_yield_zero_or_one_not_a_count() {
let ev = |src: &str, x: f64| eval(&parse(src).unwrap(), x).unwrap();
assert_eq!(ev("x > 1 or x > 2", 5.0), 1.0);
assert_eq!(ev("x > 1 or x > 2", 0.0), 0.0);
assert_eq!(ev("x > 4 or x < 1", 5.0), 1.0);
assert_eq!(ev("x > 1 or x > 2 or x > 3", 9.0), 1.0);
assert_eq!(ev("x in [1,1,1]", 1.0), 1.0);
assert_eq!(ev("x in [1,5,5,9]", 5.0), 1.0);
assert_eq!(ev("x in [1,2,3]", 7.0), 0.0);
assert_eq!(ev("x in [5]", 5.0), 1.0);
}
#[test]
fn parentheses_group_a_whole_expression() {
let ev = |src: &str, x: f64| eval(&parse(src).unwrap(), x).unwrap();
assert_eq!(ev("(x > 1) and (x < 5)", 3.0), 1.0);
assert_eq!(ev("(x > 1) and (x < 5)", 9.0), 0.0);
assert_eq!(ev("not (x > 1 or x > 2)", 5.0), 0.0);
assert_eq!(ev("not (x > 1 or x > 2)", 0.0), 1.0);
assert_eq!(ev("(x > 5 ? 100 : 0)", 9.0), 100.0);
assert_eq!(ev("(x > 5 ? 100 : 0)", 1.0), 0.0);
assert_eq!(ev("(x + 2) * 3", 1.0), 9.0);
assert_eq!(ev("x - (2 - 1)", 5.0), 4.0);
assert_eq!(ev("((x))", 7.0), 7.0);
}
#[test]
fn fractional_bound_still_a_number_not_a_control() {
assert!(matches!(
parse("x + .5").unwrap(),
Expr::Bin(BinOp::Add, _, _)
));
}
}