Migrate cmp/math/regex stdlib to VM-native types; fix cross-type numeric equality

- regex.rs: replace interpreter Value with ndc_vm::value::Value in nums,
  unsigned_nums, captures, capture_once — no bridge on the hot path
- cmp.rs: assert_eq/assert_ne take ndc_vm::value::Value directly
- math.rs: float() and int() match on VM Value patterns (Bool, Object::String,
  to_f64/to_number); drop unused interpreter Sequence import
- value.rs: extend Value and Object PartialEq to handle cross-type numeric
  comparisons via ndc_core::Number (e.g. Rational(5/1) == Int(5)), consistent
  with the existing PartialOrd behaviour; latent bug exposed by assert_eq migration

Co-Authored-By: Claude Sonnet 4.6 <[email protected]>

Author: timfennis

ndc_stdlib/src/cmp.rs

@@ -2,7 +2,6 @@
 mod inner {
     use anyhow::anyhow;
 
-    use ndc_interpreter::value::Value;
     use std::cmp::Ordering;
 
     /// Produces an error if the argument is not true.
@@ -15,7 +14,10 @@ mod inner {
     }
 
     /// Produces an error if the arguments aren't equal to each other.
-    pub fn assert_eq(left: &Value, right: &Value) -> anyhow::Result<()> {
+    pub fn assert_eq(
+        left: ndc_vm::value::Value,
+        right: ndc_vm::value::Value,
+    ) -> anyhow::Result<()> {
         if left == right {
             Ok(())
         } else {
@@ -26,7 +28,10 @@ mod inner {
     }
 
     /// Produces an error if the arguments are equal to each other.
-    pub fn assert_ne(left: &Value, right: &Value) -> anyhow::Result<()> {
+    pub fn assert_ne(
+        left: ndc_vm::value::Value,
+        right: ndc_vm::value::Value,
+    ) -> anyhow::Result<()> {
         if left == right {
             Err(anyhow!(format!(
                 "failed asserting that {left} does not equal {right}"

ndc_stdlib/src/math.rs

@@ -1,7 +1,6 @@
 use factorial::Factorial;
 use ndc_interpreter::environment::Environment;
 use ndc_interpreter::num::{BinaryOperatorError, Number};
-use ndc_interpreter::sequence::Sequence;
 use ndc_macros::export_module;
 use num::ToPrimitive;
 use std::ops::{Add, Mul};
@@ -13,8 +12,6 @@ mod inner {
     use anyhow::Context;
     use ndc_interpreter::int::Int;
     use ndc_interpreter::num::Number;
-    use ndc_interpreter::sequence::Sequence;
-    use ndc_interpreter::value::Value;
     use num::{BigInt, BigRational, BigUint, Integer, complex::Complex64};
 
     /// Returns the sign of a number.
@@ -110,28 +107,18 @@ mod inner {
         Ok(left.sub(right)?.abs())
     }
 
-    pub fn float(value: &Value) -> anyhow::Result<f64> {
-        match value {
-            Value::Number(Number::Int(Int::BigInt(i))) => i
-                .to_f64()
-                .ok_or_else(|| anyhow::anyhow!("failed to convert int to float (overflow?)")),
-            Value::Number(Number::Int(Int::Int64(i))) => i
+    pub fn float(value: ndc_vm::value::Value) -> anyhow::Result<f64> {
+        match &value {
+            ndc_vm::value::Value::Bool(b) => Ok(if *b { 1.0 } else { 0.0 }),
+            ndc_vm::value::Value::Object(obj) => match obj.as_ref() {
+                ndc_vm::value::Object::String(s) => Ok(s.borrow().parse::<f64>()?),
+                _ => value
+                    .to_f64()
+                    .ok_or_else(|| anyhow::anyhow!("cannot convert {} to float", value.static_type())),
+            },
+            _ => value
                 .to_f64()
-                .ok_or_else(|| anyhow::anyhow!("failed to convert int to float (overflow?)")),
-            Value::Number(Number::Rational(r)) => r
-                .to_f64()
-                .ok_or_else(|| anyhow::anyhow!("failed to convert rational to float (overflow?)")),
-            Value::Number(Number::Float(f)) => Ok(*f),
-            Value::Bool(true) => Ok(1.0),
-            Value::Bool(false) => Ok(0.0),
-            Value::Sequence(Sequence::String(string)) => {
-                let string = string.borrow();
-                Ok(string.parse::<f64>()?)
-            }
-            value => Err(anyhow::anyhow!(
-                "cannot convert {} to float",
-                value.static_type()
-            )),
+                .ok_or_else(|| anyhow::anyhow!("cannot convert {} to float", value.static_type())),
         }
     }
 
@@ -147,20 +134,25 @@ mod inner {
     /// - Rational numbers are rounded down
     /// - `true` is converted to `1`, and `false` to `0`
     /// - Strings are parsed as decimal integers; other representations result in an error
-    pub fn int(value: &Value) -> anyhow::Result<Number> {
-        match value {
-            Value::Number(number) => Ok(number.to_int_lossy()?),
-            Value::Bool(true) => Ok(Number::from(1)),
-            Value::Bool(false) => Ok(Number::from(0)),
-            Value::Sequence(Sequence::String(string)) => {
-                let string = string.borrow();
-                let bi = string.parse::<BigInt>()?;
-                Ok(Number::Int(Int::BigInt(bi).simplified()))
-            }
-            value => Err(anyhow::anyhow!(
-                "cannot convert {} to int",
-                value.static_type()
-            )),
+    pub fn int(value: ndc_vm::value::Value) -> anyhow::Result<Number> {
+        match &value {
+            ndc_vm::value::Value::Bool(b) => Ok(Number::from(if *b { 1i32 } else { 0i32 })),
+            ndc_vm::value::Value::Object(obj) => match obj.as_ref() {
+                ndc_vm::value::Object::String(s) => {
+                    let bi = s.borrow().parse::<BigInt>()?;
+                    Ok(Number::Int(Int::BigInt(bi).simplified()))
+                }
+                _ => value
+                    .to_number()
+                    .ok_or_else(|| anyhow::anyhow!("cannot convert {} to int", value.static_type()))?
+                    .to_int_lossy()
+                    .map_err(|e| anyhow::anyhow!("{e}")),
+            },
+            _ => value
+                .to_number()
+                .ok_or_else(|| anyhow::anyhow!("cannot convert {} to int", value.static_type()))?
+                .to_int_lossy()
+                .map_err(|e| anyhow::anyhow!("{e}")),
         }
     }
 }

ndc_stdlib/src/regex.rs

@@ -1,30 +1,38 @@
-use ndc_interpreter::value::Value;
 use once_cell::sync::Lazy;
 use regex::Regex;
 
 #[ndc_macros::export_module]
 mod inner {
+    use ndc_vm::value::Value;
 
     /// Extracts all signed integers from the given string.
     #[function(return_type = Vec<i64>)]
-    pub fn nums(haystack: &str) -> Value {
+    pub fn nums(haystack: &str) -> ndc_vm::value::Value {
         static RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"-?\d+").unwrap());
 
-        Value::collect_list(RE.captures_iter(haystack).filter_map(|cap| {
-            let (full, []) = cap.extract();
-            full.parse::<i64>().ok()
-        }))
+        Value::list(
+            RE.captures_iter(haystack)
+                .filter_map(|cap| {
+                    let (full, []) = cap.extract();
+                    full.parse::<i64>().ok().map(Value::Int)
+                })
+                .collect(),
+        )
     }
 
     /// Extracts all unsigned integers from the given string.
     #[function(return_type = Vec<i64>)]
-    pub fn unsigned_nums(haystack: &str) -> Value {
+    pub fn unsigned_nums(haystack: &str) -> ndc_vm::value::Value {
         static RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"\d+").unwrap());
 
-        Value::collect_list(RE.captures_iter(haystack).filter_map(|cap| {
-            let (full, []) = cap.extract();
-            full.parse::<i64>().ok()
-        }))
+        Value::list(
+            RE.captures_iter(haystack)
+                .filter_map(|cap| {
+                    let (full, []) = cap.extract();
+                    full.parse::<i64>().ok().map(Value::Int)
+                })
+                .collect(),
+        )
     }
 
     /// Returns `true` if the string matches the given regular expression.
@@ -35,7 +43,7 @@ mod inner {
 
     /// Returns all capture groups from the first match of the regular expression.
     #[function(return_type = Vec<String>)]
-    pub fn captures(haystack: &str, regex: &str) -> Result<Value, regex::Error> {
+    pub fn captures(haystack: &str, regex: &str) -> Result<ndc_vm::value::Value, regex::Error> {
         let r = Regex::new(regex)?;
 
         let list = r
@@ -44,7 +52,7 @@ mod inner {
                 Value::list(
                     captures
                         .iter()
-                        .filter_map(|x| x.map(|x| Value::from(x.as_str())))
+                        .filter_map(|x| x.map(|x| Value::string(x.as_str())))
                         .collect::<Vec<_>>(),
                 )
             })
@@ -55,16 +63,19 @@ mod inner {
 
     /// Returns the first capture group from the first match of the regular expression.
     #[function(return_type = Vec<String>)]
-    pub fn capture_once(haystack: &str, regex: &str) -> Result<Value, regex::Error> {
+    pub fn capture_once(
+        haystack: &str,
+        regex: &str,
+    ) -> Result<ndc_vm::value::Value, regex::Error> {
         let r = Regex::new(regex)?;
 
         let Some(captures) = r.captures(haystack) else {
-            return Ok(Value::empty_list());
+            return Ok(Value::list(vec![]));
         };
 
         let list = captures
             .iter()
-            .filter_map(|x| x.map(|x| Value::from(x.as_str())))
+            .filter_map(|x| x.map(|x| Value::string(x.as_str())))
             .collect::<Vec<_>>();
 
         Ok(Value::list(list))

ndc_vm/src/value.rs

@@ -627,14 +627,15 @@ impl PartialEq for Value {
         match (self, other) {
             (Self::Int(a), Self::Int(b)) => a == b,
             (Self::Float(a), Self::Float(b)) => OrderedFloat(*a) == OrderedFloat(*b),
-            // Cross-type numeric equality: consistent with PartialOrd's cross-numeric path.
-            (Self::Int(_), Self::Float(_)) | (Self::Float(_), Self::Int(_)) => {
-                vm_value_to_number(self) == vm_value_to_number(other)
-            }
             (Self::Bool(a), Self::Bool(b)) => a == b,
             (Self::None, Self::None) => true,
             (Self::Object(a), Self::Object(b)) => a == b,
-            _ => false,
+            // Cross-type numeric equality: delegate to Number, consistent with PartialOrd.
+            // Covers Int vs Float, Int vs Rational, Int vs BigInt, Float vs Rational, etc.
+            (a, b) => match (vm_value_to_number(a), vm_value_to_number(b)) {
+                (Some(a), Some(b)) => a == b,
+                _ => false,
+            },
         }
     }
 }
@@ -677,9 +678,6 @@ impl PartialEq for Object {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
             (Self::Some(a), Self::Some(b)) => a == b,
-            (Self::BigInt(a), Self::BigInt(b)) => a == b,
-            (Self::Complex(a), Self::Complex(b)) => a == b,
-            (Self::Rational(a), Self::Rational(b)) => a == b,
             (Self::String(a), Self::String(b)) => a.borrow().eq(&*b.borrow()),
             (Self::List(a), Self::List(b)) => a.borrow().eq(&*b.borrow()),
             (Self::Tuple(a), Self::Tuple(b)) => a == b,
@@ -720,7 +718,12 @@ impl PartialEq for Object {
             // address is equivalent to comparing the outer Rc pointers.
             (Self::MinHeap(a), Self::MinHeap(b)) => std::ptr::eq(a, b),
             (Self::MaxHeap(a), Self::MaxHeap(b)) => std::ptr::eq(a, b),
-            _ => false,
+            // Numeric types: delegate to Number for cross-type equality
+            // (e.g. BigInt(5) == Rational(5/1), Rational(5/1) == Complex(5+0i)).
+            (a, b) => match (obj_to_number(a), obj_to_number(b)) {
+                (Some(a), Some(b)) => a == b,
+                _ => false,
+            },
         }
     }
 }