hecks 3.13.0 → 4.0.0

data/rust/parser/src/parse/value_object.rs

@@ -98,7 +98,8 @@ pub fn parse_body(
             // An inline type-position `one_of(...)` set is returned beside the value object (see
             // build/closed_sets.rs); `ValueObject` has no nested-value-objects field.
             "attribute" => {
-                let (attribute, one_of, closed_set) = build_value_object_attribute(file, &gated.args)?;
+                let (attribute, one_of, closed_set) =
+                    build_value_object_attribute(file, &gated.args)?;
                 synthesized.extend(closed_set);
                 if let Some(values) = one_of {
                     let vo_name = vo.name.clone();
@@ -140,7 +141,11 @@ pub fn parse_body(
 fn build_value_object_attribute(
     file: &str,
     args: &super::ArgumentGateResult,
-) -> ParseResult<(ir::Attribute, Option<Vec<ruby_value::Value>>, Option<ir::ValueObject>)> {
+) -> ParseResult<(
+    ir::Attribute,
+    Option<Vec<ruby_value::Value>>,
+    Option<ir::ValueObject>,
+)> {
     let (attribute, closed_set) = super::build_attribute(file, 0, "attribute", args)?;
     let one_of = super::named_raw(args, "one_of").map(|raw| {
         let trimmed = raw.trim();

data/rust/parser/src/parse/world.rs

@@ -0,0 +1,322 @@
+//! The `World` construct: a `.world` file's `Hecks.world "Name" do ... end` blocks, each holding
+//! the scalar words `realm`, `latest`, `default_adapter`, `default_database` and any number of
+//! open-vocabulary bindings (`persisted_by("Heki") do ... end`, `launcher "Launcher", k: v`).
+//! Printed by `hecks-parse world`; worlds never enter `ir.json`.
+//!
+//! The settings bag is open, so a binding verb has no keyword row: it is shape-matched, and only
+//! its verb, adapter and setting names are recorded. Setting values are never read into the IR
+//! (they can be secrets) and nothing is ever evaluated.
+
+use crate::diag::{Diagnostic, ParseResult};
+use crate::ir;
+use crate::keywords;
+use crate::lex::{self, LineShape, Opener, SourceLine};
+use crate::ruby_value::{self, Value};
+
+/// Ruby methods that do something rather than name a binding. The settings bag is open, so these
+/// are the words refused by name: a `.world` file only declares, it never runs anything.
+const RUBY_KERNEL_WORDS: &[&str] = &[
+    "puts",
+    "print",
+    "p",
+    "pp",
+    "require",
+    "require_relative",
+    "load",
+    "eval",
+    "instance_eval",
+    "system",
+    "exec",
+    "spawn",
+    "raise",
+    "fail",
+    "abort",
+    "exit",
+    "sleep",
+    "send",
+    "public_send",
+    "binding",
+    "at_exit",
+    "warn",
+    "gets",
+    "open",
+];
+
+/// Parses every top-level `world` block of one `.world` file, in file order, unmerged.
+pub fn parse_file(path: &str, source: &str) -> ParseResult<Vec<ir::World>> {
+    let joined = lex::join_continuations(source);
+    let lines = lex::lines(&joined);
+    let mut pos = 0usize;
+    let mut worlds = Vec::new();
+
+    while pos < lines.len() {
+        let (row, call, header_line) = super::file::parse_header(path, &lines, &mut pos)?;
+        if row.inner != "World" {
+            return Err(Diagnostic::new(
+                path,
+                header_line,
+                format!(
+                    "a .world file's own top-level blocks must all be 'world'; got '{}'",
+                    call.word
+                ),
+            ));
+        }
+        let domain = super::file::header_name(&call)
+            .filter(|name| !name.is_empty())
+            .ok_or_else(|| {
+                Diagnostic::new(path, header_line, "'world' needs a non-empty quoted name")
+            })?;
+        worlds.push(parse_body(path, &lines, &mut pos, domain)?);
+    }
+    Ok(worlds)
+}
+
+/// Folds blocks into one world per distinct domain, in order of first appearance, as the Ruby
+/// registry does: a later scalar replaces an earlier one; a later binding replaces the earlier
+/// binding with the same key wholesale, in the earlier slot; new keys append.
+pub fn merge(blocks: Vec<ir::World>) -> Vec<ir::World> {
+    let mut merged: Vec<ir::World> = Vec::new();
+    for block in blocks {
+        let Some(existing) = merged.iter_mut().find(|w| w.domain == block.domain) else {
+            merged.push(block);
+            continue;
+        };
+        if block.realm.is_some() {
+            existing.realm = block.realm;
+        }
+        if block.latest.is_some() {
+            existing.latest = block.latest;
+        }
+        if block.default_adapter.is_some() {
+            existing.default_adapter = block.default_adapter;
+        }
+        existing.default_database |= block.default_database;
+        for binding in block.bindings {
+            upsert(&mut existing.bindings, binding);
+        }
+    }
+    merged
+}
+
+/// A repeated (verb, adapter) key keeps its first position with the last contents.
+fn upsert(bindings: &mut Vec<ir::Binding>, binding: ir::Binding) {
+    let same = |b: &ir::Binding| {
+        b.verb == binding.verb && b.adapter.to_lowercase() == binding.adapter.to_lowercase()
+    };
+    match bindings.iter_mut().find(|b| same(b)) {
+        Some(slot) => *slot = binding,
+        None => bindings.push(binding),
+    }
+}
+
+fn parse_body(
+    file: &str,
+    lines: &[SourceLine],
+    pos: &mut usize,
+    domain: String,
+) -> ParseResult<ir::World> {
+    let mut world = ir::World {
+        domain,
+        ..ir::World::default()
+    };
+    loop {
+        let line = *lines.get(*pos).ok_or_else(|| {
+            let last = lines.last().map_or(0, |l| l.number);
+            Diagnostic::new(file, last, "unexpected end of file — still inside World")
+        })?;
+        let LineShape::Call(call) = lex::classify(file, &line)? else {
+            *pos += 1;
+            return Ok(world);
+        };
+        match call.word.as_str() {
+            "default_database" => {
+                *pos += 1;
+                world.default_database = default_database_set(file, line.number, &call)?;
+            }
+            "realm" | "latest" | "default_adapter" => {
+                let gated = super::next_line(file, lines, pos, "World")?.ok_or_else(|| {
+                    Diagnostic::new(file, line.number, "unexpected 'end' inside World")
+                })?;
+                let value = scalar_text(file, line.number, &call.word, &gated.args)?;
+                match call.word.as_str() {
+                    "realm" => world.realm = Some(value),
+                    "latest" => world.latest = Some(value),
+                    _ => world.default_adapter = Some(value),
+                }
+            }
+            _ => {
+                *pos += 1;
+                let binding = parse_binding(file, lines, pos, line.number, &call)?;
+                upsert(&mut world.bindings, binding);
+            }
+        }
+    }
+}
+
+/// A non-empty string literal, as Ruby's world language requires of these words.
+fn scalar_text(
+    file: &str,
+    line: usize,
+    word: &str,
+    args: &super::ArgumentGateResult,
+) -> ParseResult<String> {
+    let raw = args.positional.first().map_or("", |(_, v)| v.trim());
+    if !raw.starts_with('"') {
+        return Err(Diagnostic::new(
+            file,
+            line,
+            format!("'{word}' takes a quoted string"),
+        ));
+    }
+    let text = super::positional_text(file, line, word, args, 1)?;
+    if text.is_empty() {
+        return Err(Diagnostic::new(
+            file,
+            line,
+            format!("'{word}' must not be empty"),
+        ));
+    }
+    Ok(text)
+}
+
+/// `default_database` takes a string or any Ruby expression (an environment lookup). The expression
+/// is neither evaluated nor kept: only that it was set. A literal empty string or `nil` refuses.
+fn default_database_set(file: &str, line: usize, call: &lex::Call) -> ParseResult<bool> {
+    let items = ruby_value::split_items(&call.args);
+    let single = items.len() == 1 && call.opener == Opener::None;
+    if !single || super::as_named(&items[0]).is_some() {
+        return Err(Diagnostic::new(
+            file,
+            line,
+            "'default_database' takes exactly one value and no block",
+        ));
+    }
+    if matches!(ruby_value::read(&items[0]), Value::Str(ref s) if s.is_empty()) || items[0] == "nil"
+    {
+        return Err(Diagnostic::new(
+            file,
+            line,
+            "'default_database' must not be empty",
+        ));
+    }
+    Ok(true)
+}
+
+/// One binding call: `verb("Adapter") do ... end`, or `verb "Adapter", k: v, ...` with no block.
+/// Records the verb, the first positional string, the keyword names, then the body's top-level
+/// keys. A verb that is a grammar word elsewhere is refused, as Ruby's word gate refuses it.
+fn parse_binding(
+    file: &str,
+    lines: &[SourceLine],
+    pos: &mut usize,
+    number: usize,
+    call: &lex::Call,
+) -> ParseResult<ir::Binding> {
+    if RUBY_KERNEL_WORDS.contains(&call.word.as_str()) {
+        return Err(Diagnostic::new(
+            file,
+            number,
+            format!(
+                "'{}' is a Ruby method, not a binding verb; a .world file only declares",
+                call.word
+            ),
+        ));
+    }
+    if keywords::KEYWORDS
+        .iter()
+        .any(|k| k.live() && k.word == call.word)
+    {
+        return Err(Diagnostic::new(
+            file,
+            number,
+            format!(
+                "'{}' is a grammar word, not a binding verb, and World does not admit it",
+                call.word
+            ),
+        ));
+    }
+    let mut adapter = None;
+    let mut settings: Vec<String> = Vec::new();
+    for item in ruby_value::split_items(&call.args) {
+        if let Some((name, _value)) = super::as_named(&item) {
+            push_unique(&mut settings, name.to_string());
+        } else if adapter.is_none() && item.starts_with('"') {
+            adapter = Some(match ruby_value::read(&item) {
+                Value::Str(s) => s,
+                other => ruby_value::to_s(&other),
+            });
+        } else {
+            return Err(Diagnostic::new(
+                file,
+                number,
+                format!(
+                    "'{}' takes one quoted adapter name, then keyword arguments",
+                    call.word
+                ),
+            ));
+        }
+    }
+    let adapter = adapter.ok_or_else(|| {
+        Diagnostic::new(
+            file,
+            number,
+            format!("'{}' needs a quoted adapter name", call.word),
+        )
+    })?;
+    match call.opener {
+        Opener::None => {}
+        Opener::DoBlock { .. } => body_keys(file, lines, pos, &mut settings)?,
+        Opener::BraceBlock { .. } => {
+            return Err(Diagnostic::new(
+                file,
+                number,
+                format!("'{}' takes a `do ... end` block, not braces", call.word),
+            ))
+        }
+    }
+    Ok(ir::Binding {
+        verb: call.word.clone(),
+        adapter,
+        settings,
+    })
+}
+
+/// Collects a binding block's top-level setting names, tracking nested blocks through the shape
+/// gate so a malformed line inside still refuses. Values are not read.
+fn body_keys(
+    file: &str,
+    lines: &[SourceLine],
+    pos: &mut usize,
+    settings: &mut Vec<String>,
+) -> ParseResult<()> {
+    let mut depth = 1;
+    while depth > 0 {
+        let line = *lines.get(*pos).ok_or_else(|| {
+            let last = lines.last().map_or(0, |l| l.number);
+            Diagnostic::new(
+                file,
+                last,
+                "unexpected end of file — still inside a binding block",
+            )
+        })?;
+        *pos += 1;
+        match lex::classify(file, &line)? {
+            LineShape::End => depth -= 1,
+            LineShape::Call(call) => {
+                if depth == 1 {
+                    push_unique(settings, call.word.clone());
+                }
+                if matches!(call.opener, Opener::DoBlock { .. }) {
+                    depth += 1;
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+fn push_unique(names: &mut Vec<String>, name: String) {
+    if !names.contains(&name) {
+        names.push(name);
+    }
+}

data/rust/parser/src/ruby_value.rs

@@ -10,8 +10,8 @@ pub enum Value {
     Float(f64),
     Str(String),
     Symbol(String),
-    Hash(Vec<(String, Value)>),
-    Array(Vec<Value>),
+    Hash(Vec<(String, Self)>),
+    Array(Vec<Self>),
     /// A bare word `Literal.read` tolerates; kept apart from `Str` so `render` adds no quotes.
     Bare(String),
 }
@@ -306,9 +306,7 @@ fn scan_adjacent_strings(raw: &str) -> Option<(String, usize)> {
         }
 
         // Defensive: return `None` rather than panic on an empty or odd `raw`.
-        let Some(&quote) = chars.get(i).filter(|c| **c == '"' || **c == '\'') else {
-            return None;
-        };
+        let &quote = chars.get(i).filter(|c| **c == '"' || **c == '\'')?;
 
         let start = i;
         i += 1;
@@ -487,7 +485,10 @@ mod tests {
     #[test]
     fn double_quoted_escapes_read_as_ruby_reads_them() {
         assert_eq!(read(r#""a\tb\nc""#), Value::Str("a\tb\nc".to_string()));
-        assert_eq!(read(r#""\e\s\a\0""#), Value::Str("\u{1b} \u{7}\0".to_string()));
+        assert_eq!(
+            read(r#""\e\s\a\0""#),
+            Value::Str("\u{1b} \u{7}\0".to_string())
+        );
         assert_eq!(
             read(r#""\x41\101é\u{1F4A5 41}""#),
             Value::Str("AA\u{e9}\u{1F4A5}A".to_string())

data/rust/src/exemplar/json.rs

@@ -10,7 +10,7 @@ impl TmplKind {
     pub fn to_json(&self) -> crate::kernel::Json {
         let member = match self {
             // TMPL:closed_set_codec:TO_JSON_ARM BEGIN
-            TmplKind::TmplMemberA => "tmpl_member_a",
+            Self::TmplMemberA => "tmpl_member_a",
             // TMPL:closed_set_codec:TO_JSON_ARM END
         };
         crate::kernel::Json::obj(vec![("tmpl_field_name", crate::kernel::Json::str(member))])
@@ -21,7 +21,7 @@ impl TmplKind {
         // does in `validate!`: before a missing field, and before membership.
         let unknown = v.unknown_keys(&["tmpl_field_name"]);
         if !unknown.is_empty() {
-            let unknown: Vec<&str> = unknown.iter().map(|key| key.as_str()).collect();
+            let unknown: Vec<&str> = unknown.iter().map(String::as_str).collect();
             return Err(crate::kernel::Refusal::UnknownArgument(
                 crate::kernel::refusal_wording::UnknownArgumentUnknownArgsArgs {
                     command: "tmpl_closed_set_type",
@@ -72,7 +72,7 @@ impl TmplKind {
         }
         match candidate.ruby_to_s().as_str() {
             // TMPL:closed_set_codec:FROM_JSON_ARM BEGIN
-            "tmpl_member_a" => Ok(TmplKind::TmplMemberA),
+            "tmpl_member_a" => Ok(Self::TmplMemberA),
             // TMPL:closed_set_codec:FROM_JSON_ARM END
             _ => Err(crate::kernel::Refusal::InvariantViolation(
                 crate::kernel::refusal_wording::InvariantViolationClosedSetMemberArgs {
@@ -134,7 +134,7 @@ tmpl_to_json_fields_block()
         // membership of the whole row.
         let unknown = v.unknown_keys(&TMPL_DECLARED_NAMES);
         if !unknown.is_empty() {
-            let unknown: Vec<&str> = unknown.iter().map(|key| key.as_str()).collect();
+            let unknown: Vec<&str> = unknown.iter().map(String::as_str).collect();
             return Err(crate::kernel::Refusal::UnknownArgument(
                 crate::kernel::refusal_wording::UnknownArgumentUnknownArgsArgs {
                     command: "tmpl_table_type",

data/rust/src/exemplar/mutations.rs

@@ -78,3 +78,21 @@ fn tmpl_mutation_remove_host(record: &mut TmplRemoveHost) {
     record.tmpl_field.retain(|item| item.tmpl_id_field != tmpl_remove_match_placeholder());
     // TMPL:mutation_remove END
 }
+
+// `remove:` on a value-object list drops every element equal by value to the argument, so
+// the element type derives `PartialEq` and the retained ones are those that differ.
+#[derive(PartialEq)]
+struct TmplRemoveValueElement {
+    tmpl_value: i64,
+}
+struct TmplRemoveValueHost {
+    tmpl_field: Vec<TmplRemoveValueElement>,
+}
+fn tmpl_remove_value_placeholder() -> TmplRemoveValueElement {
+    TmplRemoveValueElement { tmpl_value: 0 }
+}
+fn tmpl_mutation_remove_value_host(record: &mut TmplRemoveValueHost) {
+    // TMPL:mutation_remove_value BEGIN
+    record.tmpl_field.retain(|item| *item != tmpl_remove_value_placeholder());
+    // TMPL:mutation_remove_value END
+}

data/rust/src/exemplar/read_models.rs

@@ -33,16 +33,7 @@ crate::kernel::read_model::ReadModelDef {
     ],
     authorization: Some(crate::kernel::named_query::TenantAuth { query_name: "tmpl_query_name", tenant_field: "tmpl_tenant_field", policy: "tmpl_policy" }),
     group_by: None,
-    count: false,
-    median_field: None,
-    sum_field: None,
-    avg_field: None,
-    min_field: None,
-    max_field: None,
-    percentile_field: None,
-    percentile_at: None,
-    any_field: None,
-    all_field: None,
+    reduction: None,
 },
 ];
 // TMPL:read_model_table END

data/rust/src/kernel/attribute_shapes/composite.rs

@@ -5,9 +5,11 @@ use crate::kernel::Refusal;
 
 /// A scalar (or `Nil`) with segments left resolves to `Nil`, like Ruby's `walk_path`.
 /// This makes `flag.nil?` read as a value instead of a refusal.
-pub fn step<'a>(current: Field<'a>, seg: &str, head: &str) -> Result<Field<'a>, Refusal> {
+pub fn step<'a>(current: &Field<'a>, seg: &str, head: &str) -> Result<Field<'a>, Refusal> {
     match current {
-        Field::Nested(obj) => obj.field(seg).ok_or_else(|| eval_error(format!("cannot resolve {seg:?} on {head:?}"))),
+        Field::Nested(obj) => (*obj)
+            .field(seg)
+            .ok_or_else(|| eval_error(format!("cannot resolve {seg:?} on {head:?}"))),
         Field::Value(_) => Ok(Field::Value(Value::Nil)),
     }
 }
@@ -16,7 +18,9 @@ pub fn step<'a>(current: Field<'a>, seg: &str, head: &str) -> Result<Field<'a>,
 pub fn finish(current: Field<'_>, path: &str) -> Result<Value, Refusal> {
     match current {
         Field::Value(v) => Ok(v),
-        Field::Nested(obj) => obj.as_scalar().ok_or_else(|| eval_error(format!("{path} resolved to an object, not a scalar"))),
+        Field::Nested(obj) => obj
+            .as_scalar()
+            .ok_or_else(|| eval_error(format!("{path} resolved to an object, not a scalar"))),
     }
 }
 
@@ -39,50 +43,86 @@ mod tests {
     }
 
     // `Field` derives neither `Debug` nor `PartialEq`; assertions compare the `finish`ed `Value`.
-    fn stepped_value(current: Field<'_>, seg: &str, head: &str) -> Value {
+    fn stepped_value(current: &Field<'_>, seg: &str, head: &str) -> Value {
         finish(step(current, seg, head).unwrap(), "test.path").unwrap()
     }
 
     #[test]
     fn a_further_segment_on_a_bool_scalar_resolves_to_nil_not_a_refusal() {
         // `.nil?` has no dedicated node, so it arrives as a trailing segment on a resolved scalar.
-        assert_eq!(stepped_value(Field::Value(Value::Bool(true)), "nil?", "previous_sessions"), Value::Nil);
+        assert_eq!(
+            stepped_value(
+                &Field::Value(Value::Bool(true)),
+                "nil?",
+                "previous_sessions"
+            ),
+            Value::Nil
+        );
     }
 
     #[test]
     fn this_holds_for_a_false_scalar_too() {
-        assert_eq!(stepped_value(Field::Value(Value::Bool(false)), "nil?", "previous_sessions"), Value::Nil);
+        assert_eq!(
+            stepped_value(
+                &Field::Value(Value::Bool(false)),
+                "nil?",
+                "previous_sessions"
+            ),
+            Value::Nil
+        );
     }
 
     #[test]
     fn this_holds_for_every_scalar_shape_not_just_bool() {
-        for value in [Value::Int(0), Value::Float(1.5), Value::Str("x".to_string()), Value::List(3)] {
-            assert_eq!(stepped_value(Field::Value(value.clone()), "nil?", "head"), Value::Nil, "expected Nil for {value:?}");
+        for value in [
+            Value::Int(0),
+            Value::Float(1.5),
+            Value::Str("x".to_string()),
+            Value::List(3),
+        ] {
+            assert_eq!(
+                stepped_value(&Field::Value(value.clone()), "nil?", "head"),
+                Value::Nil,
+                "expected Nil for {value:?}"
+            );
         }
     }
 
     #[test]
     fn a_further_segment_on_an_already_nil_value_stays_nil() {
         // An unset optional field already reads as `Nil` before `step` runs.
-        assert_eq!(stepped_value(Field::Value(Value::Nil), "nil?", "superseded_by"), Value::Nil);
+        assert_eq!(
+            stepped_value(&Field::Value(Value::Nil), "nil?", "superseded_by"),
+            Value::Nil
+        );
     }
 
     #[test]
     fn a_real_nested_field_still_walks_normally() {
-        let customer = Customer { status: "active".to_string() };
-        assert_eq!(stepped_value(Field::Nested(&customer), "status", "customer"), Value::Str("active".to_string()));
+        let customer = Customer {
+            status: "active".to_string(),
+        };
+        assert_eq!(
+            stepped_value(&Field::Nested(&customer), "status", "customer"),
+            Value::Str("active".to_string())
+        );
     }
 
     #[test]
     fn an_unknown_nested_field_still_refuses() {
         // A generated `field()` is exhaustive, so an unknown name is a codegen bug: keep refusing.
-        let customer = Customer { status: "active".to_string() };
-        let stepped = step(Field::Nested(&customer), "not_a_real_field", "customer");
+        let customer = Customer {
+            status: "active".to_string(),
+        };
+        let stepped = step(&Field::Nested(&customer), "not_a_real_field", "customer");
         assert!(stepped.is_err());
     }
 
     #[test]
     fn finish_unwraps_a_resolved_nil_to_a_plain_value() {
-        assert_eq!(finish(Field::Value(Value::Nil), "previous_sessions.nil?").unwrap(), Value::Nil);
+        assert_eq!(
+            finish(Field::Value(Value::Nil), "previous_sessions.nil?").unwrap(),
+            Value::Nil
+        );
     }
 }

data/rust/src/kernel/attribute_shapes/list.rs

@@ -3,14 +3,14 @@
 
 use crate::kernel::expr::Value;
 
-pub fn is_empty(v: &Value) -> Option<bool> {
+pub const fn is_empty(v: &Value) -> Option<bool> {
     match v {
         Value::List(n) => Some(*n == 0),
         _ => None,
     }
 }
 
-pub fn size(v: &Value) -> Option<i64> {
+pub const fn size(v: &Value) -> Option<i64> {
     match v {
         Value::List(n) => Some(*n as i64),
         _ => None,

data/rust/src/kernel/attribute_shapes/mod.rs

@@ -6,10 +6,10 @@
 // `for_attribute` itself takes, read directly rather than
 // re-derived here.
 
-pub mod scalar;
+pub mod composite;
 pub mod list;
 pub mod optional;
-pub mod composite;
+pub mod scalar;
 
 /// One variant per real attribute shape the Ruby
 /// grammar admits, in the order Coercion::SHAPES declares them. Every match
@@ -31,14 +31,14 @@ impl AttributeShape {
     /// variant names — `hecks measure_kernel_coverage`'s own existence
     /// check reads this, so the file-name spelling here is the ONE
     /// place that ever needs to change if a name is renamed.
-    pub fn module_name(&self) -> &'static str {
+    pub const fn module_name(&self) -> &'static str {
         match self {
-            AttributeShape::Scalar => "scalar",
-            AttributeShape::List => "list",
-            AttributeShape::Optional => "optional",
-            AttributeShape::Composite => "composite",
+            Self::Scalar => "scalar",
+            Self::List => "list",
+            Self::Optional => "optional",
+            Self::Composite => "composite",
         }
     }
 
-    pub const ALL: &'static [AttributeShape] = &[AttributeShape::Scalar, AttributeShape::List, AttributeShape::Optional, AttributeShape::Composite];
+    pub const ALL: &'static [Self] = &[Self::Scalar, Self::List, Self::Optional, Self::Composite];
 }

data/rust/src/kernel/attribute_shapes/scalar.rs

@@ -4,7 +4,7 @@
 use crate::kernel::expr::Value;
 
 // Mirrors `Resolver.numeric`: `Int` and `Float` mix freely; any other `Value` is not a number.
-pub fn numeric(v: &Value) -> Option<f64> {
+pub const fn numeric(v: &Value) -> Option<f64> {
     match v {
         Value::Int(i) => Some(*i as f64),
         Value::Float(f) => Some(*f),
@@ -24,7 +24,7 @@ pub fn to_s(v: &Value) -> Option<Value> {
 }
 
 // Only `Str` has a length; `Int`/`Float`/`Bool` answer `None` so the caller refuses.
-pub fn is_empty(v: &Value) -> Option<bool> {
+pub const fn is_empty(v: &Value) -> Option<bool> {
     match v {
         Value::Str(s) => Some(s.is_empty()),
         _ => None,