Perf: add Value::is_number, avoid O(n) static_type in hot path

static_type() on List/Map/Deque now iterates elements (lub).  The
vectorization_pairs and as_numeric_tuple helpers called it on container
values during every 2-arg dynamic dispatch.  Replace with is_number()
which is O(1) and never allocates.  Add # Performance doc warning to
static_type() pointing to is_number as the safe alternative.

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

Author: timfennis

ndc_vm/src/value/mod.rs

@@ -203,6 +203,15 @@ impl Value {
         }
     }
 
+    /// Returns the static type of this value.
+    ///
+    /// # Performance
+    ///
+    /// **O(n) for `List`, `Map`, and `Deque`** — these variants iterate all
+    /// elements to compute the element type via `lub`.  Avoid calling this in
+    /// hot paths on container values.  Use the dedicated helpers instead:
+    ///
+    /// - [`Value::is_number`] — O(1) check for numeric types
     pub fn static_type(&self) -> StaticType {
         match self {
             Self::Int(_) => StaticType::Int,
@@ -213,6 +222,21 @@ impl Value {
         }
     }
 
+    /// Returns `true` if this value is a numeric type (Int, Float, Rational, or Complex).
+    ///
+    /// Prefer this over `self.static_type().is_number()` in hot paths — this is O(1)
+    /// and never allocates, whereas `static_type()` on containers is O(n).
+    pub fn is_number(&self) -> bool {
+        match self {
+            Self::Int(_) | Self::Float(_) => true,
+            Self::Object(obj) => matches!(
+                obj.as_ref(),
+                Object::BigInt(_) | Object::Rational(_) | Object::Complex(_)
+            ),
+            _ => false,
+        }
+    }
+
     /// Consume this value and produce an iterator over its elements.
     ///
     /// Returns `None` for non-iterable types (`Int`, `Float`, `Bool`, `None`,

ndc_vm/src/vm.rs

@@ -986,7 +986,7 @@ fn as_numeric_tuple(value: &Value) -> Option<&Vec<Value>> {
     let Object::Tuple(elems) = obj.as_ref() else {
         return None;
     };
-    if !elems.is_empty() && elems.iter().all(|e| e.static_type().is_number()) {
+    if !elems.is_empty() && elems.iter().all(|e| e.is_number()) {
         Some(elems)
     } else {
         None
@@ -1003,8 +1003,8 @@ fn as_numeric_tuple(value: &Value) -> Option<&Vec<Value>> {
 fn vectorization_pairs(left: &Value, right: &Value) -> Option<Vec<(Value, Value)>> {
     let left_tuple = as_numeric_tuple(left);
     let right_tuple = as_numeric_tuple(right);
-    let left_is_scalar = left.static_type().is_number();
-    let right_is_scalar = right.static_type().is_number();
+    let left_is_scalar = left.is_number();
+    let right_is_scalar = right.is_number();
 
     match (left_tuple, right_tuple) {
         (Some(ls), Some(rs)) if ls.len() == rs.len() => {