Extract shared SExpr fast-path compilation to compiled_expr module

Introduces src/traversal/compiled_expr.rs with CompiledPredicate and
CompiledWeightExpr, eliminating per-edge interpreter allocations for
common (op field const) patterns. Both vertex/edge filters and weight
expressions now compile once per traversal job and evaluate zero-
allocation on the hot path.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: shisoft

src/traversal/compiled_expr.rs

@@ -0,0 +1,332 @@
+/// Compiled Lisp expression fast paths for the traversal hot loops.
+///
+/// Evaluation of Lisp predicates and weight expressions through `Interpreter::new()`
+/// is expensive: it allocates a fresh interpreter and clones the `SerdeExpr` tree on
+/// every call.  For the overwhelmingly common single-expression forms we skip the
+/// interpreter entirely and evaluate inline against `SharedValue` map data.
+///
+/// Two compiled types are provided:
+///
+/// * [`CompiledPredicate`] — a boolean `(op field const)` filter used by both
+///   vertex and edge filter paths.
+/// * [`CompiledWeightExpr`] — a scalar weight computation covering the most common
+///   weight expression patterns without interpreter overhead.
+///
+/// Both fall back to the full Lisp interpreter for anything that cannot be compiled
+/// to a fast path, preserving correctness for complex expressions.
+use bifrost_hasher::hash_str;
+use dovahkiin::expr::serde::Expr as SerdeExpr;
+use dovahkiin::types::{Map, OwnedMap, OwnedValue};
+use neb::dovahkiin::expr::interpreter::Interpreter;
+use neb::dovahkiin::expr::symbols::utils::is_true;
+use neb::dovahkiin::expr::{SExpr, Value};
+use neb::ram::types::SharedValue;
+use std::sync::LazyLock;
+
+// ─── Shared primitives ────────────────────────────────────────────────────────
+
+/// Hash of the synthetic `"weight"` field injected for body-less edges.
+pub static WEIGHT_FIELD_ID: LazyLock<u64> = LazyLock::new(|| hash_str("weight"));
+
+/// Comparison operator for `CompiledPredicate`.
+#[derive(Clone, Copy, Debug)]
+pub enum CmpOp {
+    Eq,
+    Ne,
+    Gt,
+    Gte,
+    Lt,
+    Lte,
+}
+
+impl CmpOp {
+    pub fn from_str(s: &str) -> Option<Self> {
+        match s {
+            "=" => Some(CmpOp::Eq),
+            "!=" => Some(CmpOp::Ne),
+            ">" => Some(CmpOp::Gt),
+            ">=" => Some(CmpOp::Gte),
+            "<" => Some(CmpOp::Lt),
+            "<=" => Some(CmpOp::Lte),
+            _ => None,
+        }
+    }
+
+    /// Compare two `SharedValue`s inline.  Zero allocation.
+    pub fn compare(self, lhs: &SharedValue<'_>, rhs: &SharedValue<'_>) -> bool {
+        match self {
+            CmpOp::Eq => lhs == rhs,
+            CmpOp::Ne => lhs != rhs,
+            CmpOp::Gt => sv_cmp(lhs, rhs).map_or(false, |o| o == std::cmp::Ordering::Greater),
+            CmpOp::Gte => sv_cmp(lhs, rhs).map_or(false, |o| o != std::cmp::Ordering::Less),
+            CmpOp::Lt => sv_cmp(lhs, rhs).map_or(false, |o| o == std::cmp::Ordering::Less),
+            CmpOp::Lte => sv_cmp(lhs, rhs).map_or(false, |o| o != std::cmp::Ordering::Greater),
+        }
+    }
+
+    /// Compare an f64 (body-less edge weight) against a constant `SharedValue` RHS.
+    pub fn compare_f64(self, lhs: f64, rhs: &SharedValue<'_>) -> bool {
+        let rhs_f = match rhs {
+            SharedValue::F64(v) => **v,
+            SharedValue::F32(v) => **v as f64,
+            SharedValue::I64(v) => **v as f64,
+            SharedValue::I32(v) => **v as f64,
+            SharedValue::U64(v) => **v as f64,
+            SharedValue::U32(v) => **v as f64,
+            _ => return false,
+        };
+        match self {
+            CmpOp::Eq => lhs == rhs_f,
+            CmpOp::Ne => lhs != rhs_f,
+            CmpOp::Gt => lhs > rhs_f,
+            CmpOp::Gte => lhs >= rhs_f,
+            CmpOp::Lt => lhs < rhs_f,
+            CmpOp::Lte => lhs <= rhs_f,
+        }
+    }
+}
+
+/// Numeric ordering for `SharedValue` pairs of the same type.
+/// Returns `None` for non-numeric or type-mismatched pairs.
+pub fn sv_cmp(lhs: &SharedValue<'_>, rhs: &SharedValue<'_>) -> Option<std::cmp::Ordering> {
+    macro_rules! cmp_variant {
+        ($($v:ident),*) => {
+            $(
+                if let (SharedValue::$v(a), SharedValue::$v(b)) = (lhs, rhs) {
+                    return (**a).partial_cmp(*b);
+                }
+            )*
+        };
+    }
+    cmp_variant!(I8, I16, I32, I64, U8, U16, U32, U64, F32, F64);
+    None
+}
+
+/// Extract a named field from a `SharedValue` map and convert to `f64`.
+pub fn field_as_f64(sv: Option<&SharedValue<'_>>, field_id: u64) -> Option<f64> {
+    if let Some(SharedValue::Map(m)) = sv {
+        return sv_to_f64(m.get_by_key_id(field_id));
+    }
+    None
+}
+
+/// Convert a `SharedValue` scalar to `f64`.  Returns `None` for non-numeric types.
+pub fn sv_to_f64(sv: &SharedValue<'_>) -> Option<f64> {
+    match sv {
+        SharedValue::F64(v) => Some(**v),
+        SharedValue::F32(v) => Some(**v as f64),
+        SharedValue::I64(v) => Some(**v as f64),
+        SharedValue::I32(v) => Some(**v as f64),
+        SharedValue::U64(v) => Some(**v as f64),
+        SharedValue::U32(v) => Some(**v as f64),
+        SharedValue::U16(v) => Some(**v as f64),
+        SharedValue::U8(v) => Some(**v as f64),
+        _ => None,
+    }
+}
+
+// ─── Interpreter fallback ─────────────────────────────────────────────────────
+
+/// Core interpreter evaluation: binds `shared` as global_val and evaluates `filter`.
+///
+/// SAFETY: `interp` and `shared` both live in this stack frame.
+pub fn eval_with_shared_val(filter: &[SerdeExpr], shared: &SharedValue<'_>) -> bool {
+    let exprs: Vec<_> = filter.iter().cloned().map(|e| e.to_sexpr()).collect();
+    let mut interp = Interpreter::new();
+    unsafe { interp.unsafe_set_global_val(shared) };
+    matches!(interp.eval(exprs), Ok(result) if is_true(&result))
+}
+
+/// Interpreter fallback for weight expressions that were not compiled to a fast path.
+pub fn eval_weight_expr_interp(
+    exprs: &[SerdeExpr],
+    schema_weight: f64,
+    edge_sv: Option<&SharedValue<'_>>,
+) -> f64 {
+    let sexpr_list: Vec<SExpr> = exprs.iter().cloned().map(|e| e.to_sexpr()).collect();
+    let mut interp = Interpreter::new();
+    interp.bind(
+        "schema_weight",
+        SExpr::Value(Value::Owned(OwnedValue::F64(schema_weight))),
+    );
+    if let Some(sv) = edge_sv {
+        unsafe { interp.unsafe_set_global_val(sv) };
+    }
+    match interp.eval(sexpr_list) {
+        Ok(result) => sv_to_f64(
+            &result
+                .shared_val()
+                .unwrap_or(SharedValue::Null),
+        )
+        .unwrap_or(schema_weight),
+        Err(_) => schema_weight,
+    }
+}
+
+// ─── CompiledPredicate ────────────────────────────────────────────────────────
+
+/// A pre-compiled boolean predicate for vertex and edge filters.
+///
+/// Handles the common `(op field_name constant)` pattern with zero heap allocation
+/// per evaluation.  Complex expressions fall back to the Lisp interpreter.
+#[derive(Clone)]
+pub enum CompiledPredicate {
+    /// Fast path: `(op field_name constant)`.  Zero allocation per eval.
+    FieldCmp {
+        field_id: u64,
+        op: CmpOp,
+        /// Constant RHS value, owned once at compile time.
+        rhs: OwnedValue,
+    },
+    /// Fallback: full Lisp interpreter.  Allocates per evaluation.
+    Expr(Vec<SerdeExpr>),
+}
+
+impl CompiledPredicate {
+    /// Compile `exprs` into the fast path if possible, otherwise fall back to `Expr`.
+    pub fn compile(exprs: &[SerdeExpr]) -> Self {
+        if let [SerdeExpr::List(inner)] = exprs {
+            if let [SerdeExpr::Symbol(_, op_str), SerdeExpr::Symbol(field_id, _), SerdeExpr::Value(rhs)] =
+                inner.as_slice()
+            {
+                if let Some(op) = CmpOp::from_str(op_str) {
+                    return Self::FieldCmp {
+                        field_id: *field_id,
+                        op,
+                        rhs: rhs.clone(),
+                    };
+                }
+            }
+        }
+        Self::Expr(exprs.to_vec())
+    }
+
+    /// Evaluate the predicate against a `SharedValue` (vertex or edge body data).
+    /// Zero allocation for `FieldCmp`.
+    pub fn eval(&self, sv: &SharedValue<'_>) -> bool {
+        match self {
+            Self::FieldCmp { field_id, op, rhs } => {
+                if let SharedValue::Map(m) = sv {
+                    op.compare(m.get_by_key_id(*field_id), &rhs.shared())
+                } else {
+                    false
+                }
+            }
+            Self::Expr(filter) => eval_with_shared_val(filter, sv),
+        }
+    }
+
+    /// Evaluate against a body-less edge where only the synthetic `"weight"` field
+    /// is available (passed as `weight: f64`).
+    pub fn eval_bodyless_edge(&self, weight: f64) -> bool {
+        match self {
+            Self::FieldCmp { field_id, op, rhs } => {
+                if *field_id == *WEIGHT_FIELD_ID {
+                    op.compare_f64(weight, &rhs.shared())
+                } else {
+                    false // fail-closed: field not available on body-less edge
+                }
+            }
+            Self::Expr(filter) => {
+                let mut map = OwnedMap::new();
+                map.insert("weight", OwnedValue::F64(weight));
+                let owned = OwnedValue::Map(map);
+                eval_with_shared_val(filter, &owned.shared())
+            }
+        }
+    }
+}
+
+// ─── CompiledWeightExpr ───────────────────────────────────────────────────────
+
+/// A pre-compiled weight expression for `WeightSpec::Expression`.
+///
+/// Covers the most common patterns without interpreter overhead:
+///
+/// | Expression form                       | Compiled variant  |
+/// |---------------------------------------|-------------------|
+/// | `field_name` (symbol)                 | `FieldOnly`       |
+/// | `(* schema_weight field)` or reversed | `ScaleField`      |
+/// | `(* constant field)` or reversed      | `ScaleField`      |
+/// | `3.14` (literal float)                | `Constant`        |
+/// | anything else                         | `Expr` (fallback) |
+#[derive(Clone)]
+pub enum CompiledWeightExpr {
+    /// Read a named field as f64, falling back to `schema_weight` if absent.
+    FieldOnly { field_id: u64 },
+    /// Multiply a named field by a constant factor.
+    ScaleField { field_id: u64, factor: f64 },
+    /// Always return this constant weight.
+    Constant(f64),
+    /// Full interpreter fallback.
+    Expr(Vec<SerdeExpr>),
+}
+
+impl CompiledWeightExpr {
+    /// Compile `exprs` into the fast path, with `schema_weight` inlined for
+    /// expressions that reference it symbolically.
+    pub fn compile(exprs: &[SerdeExpr], schema_weight: f64) -> Self {
+        match exprs {
+            // `field_name` — bare symbol used as weight
+            [SerdeExpr::Symbol(field_id, _)] => Self::FieldOnly { field_id: *field_id },
+
+            // `3.14` — literal constant
+            [SerdeExpr::Value(OwnedValue::F64(c))] => Self::Constant(*c),
+            [SerdeExpr::Value(OwnedValue::F32(c))] => Self::Constant(*c as f64),
+
+            // `(* a b)` — multiplication; supports schema_weight symbol or literal factor
+            [SerdeExpr::List(inner)] => {
+                if let [SerdeExpr::Symbol(_, op_str), a, b] = inner.as_slice() {
+                    if op_str == "*" {
+                        if let Some((field_id, factor)) = extract_scale(a, b, schema_weight)
+                            .or_else(|| extract_scale(b, a, schema_weight))
+                        {
+                            return Self::ScaleField { field_id, factor };
+                        }
+                    }
+                }
+                Self::Expr(exprs.to_vec())
+            }
+
+            _ => Self::Expr(exprs.to_vec()),
+        }
+    }
+
+    /// Evaluate the weight expression.  Zero allocation for all non-`Expr` variants.
+    pub fn eval(&self, schema_weight: f64, edge_sv: Option<&SharedValue<'_>>) -> f64 {
+        match self {
+            Self::FieldOnly { field_id } => {
+                field_as_f64(edge_sv, *field_id).unwrap_or(schema_weight)
+            }
+            Self::ScaleField { field_id, factor } => {
+                field_as_f64(edge_sv, *field_id)
+                    .map(|v| v * factor)
+                    .unwrap_or(schema_weight)
+            }
+            Self::Constant(c) => *c,
+            Self::Expr(exprs) => eval_weight_expr_interp(exprs, schema_weight, edge_sv),
+        }
+    }
+}
+
+/// Try to extract `(field_symbol, factor)` from `(factor_expr, field_expr)`.
+/// `factor_expr` may be the `schema_weight` symbol or a numeric literal.
+fn extract_scale(
+    factor_expr: &SerdeExpr,
+    field_expr: &SerdeExpr,
+    schema_weight: f64,
+) -> Option<(u64, f64)> {
+    let field_id = match field_expr {
+        SerdeExpr::Symbol(id, _) => *id,
+        _ => return None,
+    };
+    let factor = match factor_expr {
+        SerdeExpr::Symbol(_, name) if name == "schema_weight" => schema_weight,
+        SerdeExpr::Value(OwnedValue::F64(v)) => *v,
+        SerdeExpr::Value(OwnedValue::F32(v)) => *v as f64,
+        SerdeExpr::Value(OwnedValue::I64(v)) => *v as f64,
+        SerdeExpr::Value(OwnedValue::I32(v)) => *v as f64,
+        _ => return None,
+    };
+    Some((field_id, factor))
+}