hecks 3.14.0 → 4.0.0

data/rust/src/kernel/expression_operators/arithmetic.rs

@@ -12,7 +12,11 @@ pub fn binary(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
         Expr::Sub(l, r) => ("subtraction", "-", l, r),
         Expr::Mul(l, r) => ("multiplication", "*", l, r),
         Expr::Div(l, r) => ("division", "/", l, r),
-        _ => return Err(Refusal::TypeMismatch(format!("arithmetic::binary called with a non-binary node {expr:?} — a router bug"))),
+        _ => {
+            return Err(Refusal::TypeMismatch(format!(
+                "arithmetic::binary called with a non-binary node {expr:?} — a router bug"
+            )))
+        }
     };
     let (left, right) = (eval(l, ctx)?, eval(r, ctx)?);
     match symbol {
@@ -25,20 +29,49 @@ pub fn binary(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
 
 // Integer operands use the checked operation; anything else is a Float result that must stay
 // finite, as `add` does. Ruby promotes to Bignum; this kernel refuses instead.
-fn checked(name: &str, symbol: &str, lhs: &Value, rhs: &Value, int_op: fn(i64, i64) -> Option<i64>, float_op: fn(f64, f64) -> f64) -> Result<Value, Refusal> {
+fn checked(
+    name: &str,
+    symbol: &str,
+    lhs: &Value,
+    rhs: &Value,
+    int_op: fn(i64, i64) -> Option<i64>,
+    float_op: fn(f64, f64) -> f64,
+) -> Result<Value, Refusal> {
     if let (Value::Int(l), Value::Int(r)) = (lhs, rhs) {
-        return int_op(*l, *r).map(Value::Int).ok_or_else(|| eval_error(format!("{name} overflowed: {l} {symbol} {r} does not fit in a 64-bit integer")));
+        return int_op(*l, *r).map(Value::Int).ok_or_else(|| {
+            eval_error(format!(
+                "{name} overflowed: {l} {symbol} {r} does not fit in a 64-bit integer"
+            ))
+        });
     }
     let l = require_number(lhs, name)?;
     let r = require_number(rhs, name)?;
-    finite(name, symbol, l, r, float_op(l, r))
+    finite(name, symbol, (lhs, rhs), float_op(l, r))
 }
 
-fn finite(name: &str, symbol: &str, l: f64, r: f64, result: f64) -> Result<Value, Refusal> {
+// The operands are quoted as Ruby prints them: an Integer bare, a Float as `Float#to_s`.
+fn finite(
+    name: &str,
+    symbol: &str,
+    operands: (&Value, &Value),
+    result: f64,
+) -> Result<Value, Refusal> {
     if result.is_finite() {
         return Ok(Value::Float(result));
     }
-    Err(eval_error(format!("{name} overflowed: {l} {symbol} {r} is not a finite number")))
+    Err(eval_error(format!(
+        "{name} overflowed: {} {symbol} {} is not a finite number",
+        quoted(operands.0),
+        quoted(operands.1)
+    )))
+}
+
+fn quoted(v: &Value) -> String {
+    match v {
+        Value::Int(i) => i.to_string(),
+        Value::Float(f) => crate::kernel::ruby_float::to_s(*f),
+        other => format!("{other:?}"),
+    }
 }
 
 // Integer division floors toward negative infinity, as Ruby's `Integer#/` does (Rust's `/`
@@ -49,21 +82,31 @@ fn divide(lhs: &Value, rhs: &Value) -> Result<Value, Refusal> {
         return Err(eval_error("divided by 0".to_string()));
     }
     if let (Value::Int(l), Value::Int(r)) = (lhs, rhs) {
-        return floored_div(*l, *r).map(Value::Int).ok_or_else(|| eval_error(format!("division overflowed: {l} / {r} does not fit in a 64-bit integer")));
+        return floored_div(*l, *r).map(Value::Int).ok_or_else(|| {
+            eval_error(format!(
+                "division overflowed: {l} / {r} does not fit in a 64-bit integer"
+            ))
+        });
     }
     let l = require_number(lhs, "division")?;
-    finite("division", "/", l, r, l / r)
+    finite("division", "/", (lhs, rhs), l / r)
 }
 
 // `None` only for `i64::MIN / -1`, the one quotient that does not fit.
 fn floored_div(l: i64, r: i64) -> Option<i64> {
     let quotient = l.checked_div(r)?;
-    Some(if l % r != 0 && ((l < 0) != (r < 0)) { quotient - 1 } else { quotient })
+    Some(if l % r != 0 && ((l < 0) != (r < 0)) {
+        quotient - 1
+    } else {
+        quotient
+    })
 }
 
 pub fn modulo(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
     let Expr::Modulo { receiver, divisor } = expr else {
-        return Err(Refusal::TypeMismatch(format!("arithmetic::modulo called with a non-modulo node {expr:?} — a router bug")));
+        return Err(Refusal::TypeMismatch(format!(
+            "arithmetic::modulo called with a non-modulo node {expr:?} — a router bug"
+        )));
     };
 
     let r = require_number(&eval(receiver, ctx)?, "modulo")?.trunc() as i64;
@@ -75,13 +118,17 @@ pub fn modulo(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
 }
 
 // Floored like Ruby's `Integer#%` (the result takes the divisor's sign); Rust's `%` truncates.
-fn floored_mod(r: i64, d: i64) -> i64 {
+const fn floored_mod(r: i64, d: i64) -> i64 {
     // `i64::MIN % -1` overflows in Rust's `%`; every integer model answers 0 (C3.3).
     if d == -1 {
         return 0;
     }
     let raw = r % d;
-    if raw != 0 && (raw < 0) != (d < 0) { raw + d } else { raw }
+    if raw != 0 && (raw < 0) != (d < 0) {
+        raw + d
+    } else {
+        raw
+    }
 }
 
 #[cfg(test)]
@@ -102,9 +149,20 @@ mod division_tests {
 
     #[test]
     fn a_money_percentage_rounds_down() {
-        let product = checked("multiplication", "*", &Value::Int(10801), &Value::Int(50), i64::checked_mul, |a, b| a * b).unwrap();
-
-        assert_eq!(divide(&product, &Value::Int(100)).unwrap(), Value::Int(5400));
+        let product = checked(
+            "multiplication",
+            "*",
+            &Value::Int(10801),
+            &Value::Int(50),
+            i64::checked_mul,
+            |a, b| a * b,
+        )
+        .unwrap();
+
+        assert_eq!(
+            divide(&product, &Value::Int(100)).unwrap(),
+            Value::Int(5400)
+        );
     }
 
     #[test]
@@ -120,8 +178,24 @@ mod division_tests {
 
     #[test]
     fn overflowing_products_and_differences_are_faults() {
-        assert!(checked("multiplication", "*", &Value::Int(i64::MAX), &Value::Int(2), i64::checked_mul, |a, b| a * b).is_err());
-        assert!(checked("subtraction", "-", &Value::Int(i64::MIN), &Value::Int(1), i64::checked_sub, |a, b| a - b).is_err());
+        assert!(checked(
+            "multiplication",
+            "*",
+            &Value::Int(i64::MAX),
+            &Value::Int(2),
+            i64::checked_mul,
+            |a, b| a * b
+        )
+        .is_err());
+        assert!(checked(
+            "subtraction",
+            "-",
+            &Value::Int(i64::MIN),
+            &Value::Int(1),
+            i64::checked_sub,
+            |a, b| a - b
+        )
+        .is_err());
     }
 }
 
@@ -159,6 +233,18 @@ mod float_sum_tests {
         let result = sum(&Value::Float(1.0e308), &Value::Float(1.0e308));
         assert!(result.is_err(), "1e308 + 1e308 must fault, not answer inf");
     }
+
+    // The fault quotes operands as Ruby prints them, not as Rust's 309-digit expansion.
+    #[test]
+    fn quotes_the_operands_in_rubys_float_format() {
+        let fault = sum(&Value::Float(1.0e308), &Value::Float(1.0e308)).unwrap_err();
+        assert_eq!(
+            fault,
+            crate::kernel::Refusal::Fault(
+                "addition overflowed: 1.0e+308 + 1.0e+308 is not a finite number".to_string()
+            )
+        );
+    }
 }
 
 #[cfg(test)]
@@ -173,7 +259,10 @@ mod sum_tests {
 
     #[test]
     fn mixed_int_float_promotes_to_float_like_ruby_coercion() {
-        assert_eq!(sum(&Value::Int(2), &Value::Float(3.5)).unwrap(), Value::Float(5.5));
+        assert_eq!(
+            sum(&Value::Int(2), &Value::Float(3.5)).unwrap(),
+            Value::Float(5.5)
+        );
     }
 
     // Ruby's `Integer#+` promotes to Bignum and never overflows; this kernel has no bignum, so
@@ -181,18 +270,27 @@ mod sum_tests {
     #[test]
     fn refuses_cleanly_on_overflow_instead_of_panicking_or_wrapping() {
         let result = sum(&Value::Int(i64::MAX), &Value::Int(1));
-        assert!(result.is_err(), "i64::MAX + 1 must refuse, not silently wrap to i64::MIN");
+        assert!(
+            result.is_err(),
+            "i64::MAX + 1 must refuse, not silently wrap to i64::MIN"
+        );
     }
 
     #[test]
     fn refuses_cleanly_on_negative_overflow() {
         let result = sum(&Value::Int(i64::MIN), &Value::Int(-1));
-        assert!(result.is_err(), "i64::MIN + -1 must refuse, not silently wrap to i64::MAX");
+        assert!(
+            result.is_err(),
+            "i64::MIN + -1 must refuse, not silently wrap to i64::MAX"
+        );
     }
 
     #[test]
     fn does_not_refuse_right_at_the_boundary() {
-        assert_eq!(sum(&Value::Int(i64::MAX - 1), &Value::Int(1)).unwrap(), Value::Int(i64::MAX));
+        assert_eq!(
+            sum(&Value::Int(i64::MAX - 1), &Value::Int(1)).unwrap(),
+            Value::Int(i64::MAX)
+        );
     }
 }
 
@@ -200,14 +298,22 @@ mod sum_tests {
 // instead of panicking (debug) or wrapping (release).
 fn sum(lhs: &Value, rhs: &Value) -> Result<Value, Refusal> {
     if let (Value::Int(l), Value::Int(r)) = (lhs, rhs) {
-        return l.checked_add(*r).map(Value::Int).ok_or_else(|| eval_error(format!("addition overflowed: {l} + {r} does not fit in a 64-bit integer")));
+        return l.checked_add(*r).map(Value::Int).ok_or_else(|| {
+            eval_error(format!(
+                "addition overflowed: {l} + {r} does not fit in a 64-bit integer"
+            ))
+        });
     }
     let l = require_number(lhs, "addition")?;
     let r = require_number(rhs, "addition")?;
     let sum = l + r;
     // C3.4 — a non-finite Float sum faults like an Integer overflow.
     if !sum.is_finite() {
-        return Err(eval_error(format!("addition overflowed: {l} + {r} is not a finite number")));
+        return Err(eval_error(format!(
+            "addition overflowed: {} + {} is not a finite number",
+            quoted(lhs),
+            quoted(rhs)
+        )));
     }
     Ok(Value::Float(sum))
 }
@@ -236,14 +342,21 @@ mod path_operand_tests {
     struct Record(Charge);
     impl Fielded for Record {
         fn field(&self, name: &str) -> Option<Field<'_>> {
-            (name == "charged").then(|| Field::Nested(&self.0))
+            (name == "charged").then_some(Field::Nested(&self.0))
         }
     }
 
     fn percent_of(path: &'static str) -> Value {
         let times = Expr::Mul(Box::new(Expr::Lookup(path)), Box::new(Expr::Int(50)));
         let expr = Expr::Div(Box::new(times), Box::new(Expr::Int(100)));
-        interpret(&expr, &EvalContext { args: &NoFields, instance: &Record(Charge(10801)) }).expect("evaluates")
+        interpret(
+            &expr,
+            &EvalContext {
+                args: &NoFields,
+                instance: &Record(Charge(10801)),
+            },
+        )
+        .expect("evaluates")
     }
 
     #[test]

data/rust/src/kernel/expression_operators/comparison.rs

@@ -14,7 +14,9 @@ pub struct Comparison {
 
 pub fn interpret(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
     let Expr::Compare { op, left, right } = expr else {
-        return Err(Refusal::TypeMismatch(format!("comparison::interpret called with a non-comparison node {expr:?} — a router bug")));
+        return Err(Refusal::TypeMismatch(format!(
+            "comparison::interpret called with a non-comparison node {expr:?} — a router bug"
+        )));
     };
 
     let l = eval(left, ctx)?;
@@ -34,15 +36,98 @@ fn less_than(lhs: &Value, rhs: &Value) -> Result<bool, Refusal> {
         (Some(l), Some(r)) => Ok(l < r),
         _ => match (lhs, rhs) {
             (Value::Str(l), Value::Str(r)) => Ok(l < r),
-            _ => Err(eval_error(format!("comparison of {lhs:?} with {rhs:?} failed"))),
+            _ => Err(eval_error(format!(
+                "comparison of {} with {} failed",
+                ruby_class_of(lhs),
+                describe(rhs)
+            ))),
         },
     }
 }
 
+/// Names `value`'s class the way Ruby's `Evaluator.class_of` does: `nil` for nil, else the
+/// Ruby class name (`Integer`, `Float`, `String`, `TrueClass`, `FalseClass`, `Array`).
+const fn ruby_class_of(value: &Value) -> &'static str {
+    match value {
+        Value::Nil => "nil",
+        Value::Int(_) => "Integer",
+        Value::Float(_) => "Float",
+        Value::Str(_) => "String",
+        Value::Bool(true) => "TrueClass",
+        Value::Bool(false) => "FalseClass",
+        Value::List(_) | Value::Array(_) => "Array",
+    }
+}
+
+/// Renders `value` the way Ruby's `Rendering.describe` does: `nil`, JSON for an array, else
+/// `inspect`. A length-only `List` carries no elements, so it renders as an empty array.
+fn describe(value: &Value) -> String {
+    match value {
+        Value::Nil => "nil".to_string(),
+        Value::Int(n) => n.to_string(),
+        Value::Bool(b) => b.to_string(),
+        Value::Float(f) => format!("{f:?}"),
+        Value::Str(s) => format!("{s:?}"),
+        Value::List(_) => "[]".to_string(),
+        Value::Array(items) => {
+            let parts: Vec<String> = items.iter().map(describe_json).collect();
+            format!("[{}]", parts.join(","))
+        }
+    }
+}
+
+/// An array element as JSON: `null` for nil, else the same text `describe` gives.
+fn describe_json(value: &Value) -> String {
+    match value {
+        Value::Nil => "null".to_string(),
+        other => describe(other),
+    }
+}
+
 /// `pub(crate)` so `membership.rs` reuses the numeric-coerced equality for array haystacks.
+#[allow(clippy::float_cmp)] // reason: Ruby's `==` on numerics is exact IEEE equality, not a margin.
 pub(crate) fn values_equal(lhs: &Value, rhs: &Value) -> bool {
     match (scalar::numeric(lhs), scalar::numeric(rhs)) {
         (Some(l), Some(r)) => l == r,
         _ => lhs == rhs,
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn failure(lhs: &Value, rhs: &Value) -> String {
+        match less_than(lhs, rhs) {
+            Err(Refusal::Fault(message)) => message,
+            other => format!("expected a Fault, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn ordering_against_nil_reads_like_ruby() {
+        assert_eq!(
+            failure(&Value::Int(0), &Value::Nil),
+            "comparison of Integer with nil failed"
+        );
+    }
+
+    #[test]
+    fn mixed_kinds_name_the_ruby_class_then_inspect_the_other_side() {
+        assert_eq!(
+            failure(&Value::Str("a".into()), &Value::Int(5)),
+            "comparison of String with 5 failed"
+        );
+        assert_eq!(
+            failure(&Value::Nil, &Value::Str("a".into())),
+            "comparison of nil with \"a\" failed"
+        );
+        assert_eq!(
+            failure(
+                &Value::Bool(true),
+                &Value::Array(vec![Value::Int(1), Value::Nil])
+            ),
+            "comparison of TrueClass with [1,null] failed"
+        );
+    }
+}

data/rust/src/kernel/expression_operators/enumeration.rs

@@ -3,17 +3,31 @@
 // Every element is evaluated before aggregating, not short-circuited, so an error on any
 // element surfaces exactly as it does in Ruby.
 use crate::kernel::attribute_shapes::composite;
-use crate::kernel::expr::{eval_error, interpret as eval, lookup_items, BlockMode, Bound, EvalContext, Expr, Field, Value};
+use crate::kernel::expr::{
+    eval_error, interpret as eval, lookup_items, BlockMode, Bound, EvalContext, Expr, Field, Value,
+};
 use crate::kernel::Refusal;
 
 pub fn interpret(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
     match expr {
-        Expr::BlockPredicate { mode, receiver, param, predicate } => {
+        Expr::BlockPredicate {
+            mode,
+            receiver,
+            param,
+            predicate,
+        } => {
             let items = elements(receiver, ctx, mode.ruby_name())?;
             let mut outcomes = Vec::with_capacity(items.len());
             for item in items {
-                let bound = Bound { name: param, value: item, rest: ctx.args };
-                let inner = EvalContext { args: &bound, instance: ctx.instance };
+                let bound = Bound {
+                    name: param,
+                    value: item,
+                    rest: ctx.args,
+                };
+                let inner = EvalContext {
+                    args: &bound,
+                    instance: ctx.instance,
+                };
                 outcomes.push(eval(predicate, &inner)?.truthy());
             }
             Ok(Value::Bool(match mode {
@@ -22,12 +36,24 @@ pub fn interpret(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
                 BlockMode::None => !outcomes.iter().any(|b| *b),
             }))
         }
-        Expr::Find { receiver, param, predicate, path } => {
+        Expr::Find {
+            receiver,
+            param,
+            predicate,
+            path,
+        } => {
             let items = elements(receiver, ctx, "find")?;
             for item in items {
                 let accepted = {
-                    let bound = Bound { name: param, value: borrow(&item), rest: ctx.args };
-                    let inner = EvalContext { args: &bound, instance: ctx.instance };
+                    let bound = Bound {
+                        name: param,
+                        value: borrow(&item),
+                        rest: ctx.args,
+                    };
+                    let inner = EvalContext {
+                        args: &bound,
+                        instance: ctx.instance,
+                    };
                     eval(predicate, &inner)?.truthy()
                 };
                 if accepted {
@@ -37,12 +63,18 @@ pub fn interpret(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
             // Nothing matched, and a path walked from nothing is nil too.
             Ok(Value::Nil)
         }
-        _ => Err(Refusal::TypeMismatch(format!("enumeration::interpret called with a non-enumeration node {expr:?} — a router bug"))),
+        _ => Err(Refusal::TypeMismatch(format!(
+            "enumeration::interpret called with a non-enumeration node {expr:?} — a router bug"
+        ))),
     }
 }
 
 /// Only a `Lookup` names a list field; any other receiver is evaluated just to word the error.
-fn elements<'a>(receiver: &Expr, ctx: &EvalContext<'a>, op: &str) -> Result<Vec<Field<'a>>, Refusal> {
+fn elements<'a>(
+    receiver: &Expr,
+    ctx: &EvalContext<'a>,
+    op: &str,
+) -> Result<Vec<Field<'a>>, Refusal> {
     match receiver {
         Expr::Lookup(path) => lookup_items(path, ctx, op),
         other => {
@@ -64,7 +96,7 @@ fn project(item: Field<'_>, path: &[&str]) -> Result<Value, Refusal> {
     let mut current = item;
     let rendered = path.join(".");
     for seg in path {
-        current = composite::step(current, seg, "find")?;
+        current = composite::step(&current, seg, "find")?;
     }
     composite::finish(current, &format!("find {{ }}.{rendered}"))
 }
@@ -106,7 +138,12 @@ mod tests {
         fn items(&self, name: &str) -> Option<Vec<Field<'_>>> {
             match name {
                 "seats" => Some(self.seats.iter().map(|s| Field::Nested(s)).collect()),
-                "tags" => Some(self.tags.iter().map(|t| Field::Value(Value::Str(t.clone()))).collect()),
+                "tags" => Some(
+                    self.tags
+                        .iter()
+                        .map(|t| Field::Value(Value::Str(t.clone())))
+                        .collect(),
+                ),
                 _ => None,
             }
         }
@@ -114,20 +151,44 @@ mod tests {
 
     fn roster() -> Roster {
         Roster {
-            seats: vec![Seat { number: 1, taken: true }, Seat { number: 2, taken: false }, Seat { number: 3, taken: true }],
-            tags: vec!["a".to_string(), "".to_string()],
+            seats: vec![
+                Seat {
+                    number: 1,
+                    taken: true,
+                },
+                Seat {
+                    number: 2,
+                    taken: false,
+                },
+                Seat {
+                    number: 3,
+                    taken: true,
+                },
+            ],
+            tags: vec!["a".to_string(), String::new()],
             number: 99,
         }
     }
 
-    const EQ: Comparison = Comparison { less_than: false, equal: true, negated: false };
+    const EQ: Comparison = Comparison {
+        less_than: false,
+        equal: true,
+        negated: false,
+    };
 
     fn eq(left: Expr, right: Expr) -> Expr {
-        Expr::Compare { op: EQ, left: Box::new(left), right: Box::new(right) }
+        Expr::Compare {
+            op: EQ,
+            left: Box::new(left),
+            right: Box::new(right),
+        }
     }
 
     fn run(expr: &Expr, instance: &dyn Fielded) -> Value {
-        let ctx = EvalContext { args: &NoFields, instance };
+        let ctx = EvalContext {
+            args: &NoFields,
+            instance,
+        };
         eval(expr, &ctx).expect("evaluates")
     }
 
@@ -158,7 +219,11 @@ mod tests {
 
     #[test]
     fn an_empty_list_answers_like_ruby() {
-        let empty = Roster { seats: vec![], tags: vec![], number: 0 };
+        let empty = Roster {
+            seats: vec![],
+            tags: vec![],
+            number: 0,
+        };
         let over = |mode| Expr::BlockPredicate {
             mode,
             receiver: Box::new(Expr::Lookup("seats")),
@@ -193,13 +258,19 @@ mod tests {
             mode: BlockMode::None,
             receiver: Box::new(Expr::Lookup("seats")),
             param: "o",
-            predicate: Box::new(eq(Expr::Lookup("o.number"), Expr::Add(Box::new(Expr::Lookup("s.number")), Box::new(Expr::Int(1))))),
+            predicate: Box::new(eq(
+                Expr::Lookup("o.number"),
+                Expr::Add(Box::new(Expr::Lookup("s.number")), Box::new(Expr::Int(1))),
+            )),
         };
         let outer = Expr::BlockPredicate {
             mode: BlockMode::Any,
             receiver: Box::new(Expr::Lookup("seats")),
             param: "s",
-            predicate: Box::new(Expr::And(Box::new(eq(Expr::Lookup("s.taken"), Expr::Bool(false))), Box::new(inner))),
+            predicate: Box::new(Expr::And(
+                Box::new(eq(Expr::Lookup("s.taken"), Expr::Bool(false))),
+                Box::new(inner),
+            )),
         };
         assert_eq!(run(&outer, &roster()), Value::Bool(false));
     }
@@ -213,7 +284,14 @@ mod tests {
             path: &["number"],
         };
         assert_eq!(run(&free_number(false), &roster()), Value::Int(2));
-        let none_free = Roster { seats: vec![Seat { number: 1, taken: true }], tags: vec![], number: 0 };
+        let none_free = Roster {
+            seats: vec![Seat {
+                number: 1,
+                taken: true,
+            }],
+            tags: vec![],
+            number: 0,
+        };
         assert_eq!(run(&free_number(false), &none_free), Value::Nil);
     }
 
@@ -225,8 +303,14 @@ mod tests {
             param: "n",
             predicate: Box::new(Expr::Bool(true)),
         };
-        let ctx = EvalContext { args: &NoFields, instance: &roster() };
+        let ctx = EvalContext {
+            args: &NoFields,
+            instance: &roster(),
+        };
         let err = eval(&wrong, &ctx).unwrap_err();
-        assert!(format!("{err:?}").contains("any? expects a list"), "{err:?}");
+        assert!(
+            format!("{err:?}").contains("any? expects a list"),
+            "{err:?}"
+        );
     }
 }

data/rust/src/kernel/expression_operators/logical.rs

@@ -5,9 +5,15 @@ use crate::kernel::Refusal;
 
 pub fn interpret(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
     match expr {
-        Expr::Or(l, r) => Ok(Value::Bool(eval(l, ctx)?.truthy() || eval(r, ctx)?.truthy())),
-        Expr::And(l, r) => Ok(Value::Bool(eval(l, ctx)?.truthy() && eval(r, ctx)?.truthy())),
+        Expr::Or(l, r) => Ok(Value::Bool(
+            eval(l, ctx)?.truthy() || eval(r, ctx)?.truthy(),
+        )),
+        Expr::And(l, r) => Ok(Value::Bool(
+            eval(l, ctx)?.truthy() && eval(r, ctx)?.truthy(),
+        )),
         Expr::Not(n) => Ok(Value::Bool(!eval(n, ctx)?.truthy())),
-        _ => Err(Refusal::TypeMismatch(format!("logical::interpret called with a non-logical node {expr:?} — a router bug"))),
+        _ => Err(Refusal::TypeMismatch(format!(
+            "logical::interpret called with a non-logical node {expr:?} — a router bug"
+        ))),
     }
 }

data/rust/src/kernel/expression_operators/membership.rs

@@ -6,7 +6,9 @@ use crate::kernel::Refusal;
 
 pub fn interpret(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
     let Expr::Include { haystack, needle } = expr else {
-        return Err(Refusal::TypeMismatch(format!("membership::interpret called with a non-membership node {expr:?} — a router bug")));
+        return Err(Refusal::TypeMismatch(format!(
+            "membership::interpret called with a non-membership node {expr:?} — a router bug"
+        )));
     };
 
     match (eval(haystack, ctx)?, eval(needle, ctx)?) {