feat(vm): Result constructors from surface syntax + closures (#93)

## What

The next two VM-completion follow-ups from #92's roadmap: **Result
constructors from surface syntax** and **closures**. Two commits.

### 1. Result constructors + built-ins from surface syntax (`da10ac5`)
`Okay(x)`/`Oops(x)` parse as ordinary **calls**, so they were
unreachable on the VM (`UndefinedFunction`). The compiler's `Expr::Call`
now recognises them — and a few stdlib-style ops the VM already has
opcodes for — before the user-function lookup, mirroring the
interpreter's inline built-in dispatch:

`Okay`→`MakeOkay`, `Oops`→`MakeOops`, `isOkay`→`IsOkay`,
`isOops`→`IsOkay;Not`, `unwrap`→`TryUnwrap`, `len`→`Len`,
`toString`→`ToString`, `print`/`printInline`→`Print`. Also fixed
`OpCode::Print` to use `Display` (not `Debug`), matching the
interpreter.

### 2. Non-capturing closures (`5d958df`)
The compiler emitted `MakeClosure`/`Call` for lambdas, but the machine
never implemented `MakeClosure` and `CallExpr` used a broken
`Call(args.len())` (`Call` expects a *function index*, not an arg
count). Now immediately-invoked lambdas run:
- `Value` gains a `VmClosure(func_idx)` variant (non-capturing — uses
params + globals, not enclosing locals); the 5 exhaustive `Value`
matches updated (`is_truthy`, `Display`, `value_to_string`, repl, json).
- New `OpCode::CallValue(argc)`; `MakeClosure` pushes a `VmClosure`;
`CallValue` removes the closure from below its args and enters its frame
(args become locals `0..argc`). The opcode match is now exhaustive — the
`Unimplemented opcode` catch-all is gone.
- `CallExpr` emits `CallValue` instead of the buggy `Call`.

Closures are invoked via `CallExpr` (e.g. `(|x| x*2)(21)`); the parser
lowers `identifier(args)` to a named `Call` (top-level functions only),
so this is **at parity with the interpreter**, which also calls closures
only via `CallExpr`.

## Verification
- **Full lib suite green: 186 passed, 0 failed** (+5 new VM tests).
- New tests: `Okay`/`Oops`/`isOkay`/`isOops`/`unwrap`/`len`/`toString`
from source; `(|x| x*2)(21)` and `(|a,b| a+b)(15,27)`.
- `rustfmt` + `clippy` (CI mode) clean.

## Deferred follow-ups
- **Upvalue capture** for closures (enclosing locals) — needs a capture
mechanism + upvalues on `VmClosure`.
- Consent grant sources (`superpower` decls), worker statements, `.wbc`
serialization, interpreter↔VM parity harness (from #92).

🤖 Generated with [Claude Code](https://claude.com/claude-code)

https://claude.ai/code/session_013wg3Mtq2QFhYi4XVw1Z6z7

---
_Generated by [Claude
Code](https://claude.ai/code/session_013wg3Mtq2QFhYi4XVw1Z6z7)_

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: hyperpolymath

src/interpreter/mod.rs

@@ -1056,6 +1056,7 @@ impl Interpreter {
             Value::Okay(inner) => format!("Okay({})", self.value_to_string(inner)),
             Value::Oops(msg) => format!("Oops({})", msg),
             Value::Channel(_) => "<channel>".to_string(),
+            Value::VmClosure(_) => "<vm-closure>".to_string(),
         }
     }
 }

src/interpreter/value.rs

@@ -223,6 +223,9 @@ pub enum Value {
     Function(Closure),
     /// Go-style channel for concurrent communication
     Channel(ChannelHandle),
+    /// A VM bytecode closure: an index into the compiled function table.
+    /// Non-capturing for now (uses params + globals, not enclosing locals).
+    VmClosure(usize),
 }
 
 impl Value {
@@ -240,6 +243,7 @@ impl Value {
             Value::Oops(_) => false,
             Value::Function(_) => true,
             Value::Channel(ch) => !ch.is_closed(),
+            Value::VmClosure(_) => true,
         }
     }
 
@@ -304,6 +308,7 @@ impl fmt::Display for Value {
                     None => write!(f, "<chan {}>", status),
                 }
             }
+            Value::VmClosure(idx) => write!(f, "<vm-closure {}>", idx),
         }
     }
 }

src/repl.rs

@@ -85,6 +85,7 @@ impl Repl {
                     crate::interpreter::Value::Float(f) => println!("{}", f),
                     crate::interpreter::Value::String(s) => println!("\"{}\"", s),
                     crate::interpreter::Value::Bool(b) => println!("{}", b),
+                    crate::interpreter::Value::VmClosure(idx) => println!("<vm-closure {}>", idx),
                     crate::interpreter::Value::Array(arr) => {
                         print!("[");
                         for (i, val) in arr.iter().enumerate() {

src/stdlib/json.rs

@@ -147,6 +147,9 @@ fn value_to_json_string(value: &Value) -> Result<String, StdlibError> {
         Value::Okay(_) | Value::Oops(_) => Err(StdlibError::RuntimeError(
             "Cannot stringify Result to JSON".to_string(),
         )),
+        Value::VmClosure(_) => Err(StdlibError::RuntimeError(
+            "Cannot stringify closure to JSON".to_string(),
+        )),
     }
 }
 

src/vm/bytecode.rs

@@ -69,8 +69,10 @@ pub enum OpCode {
     Call(usize),
     /// Return from function
     Return,
-    /// Create a closure
+    /// Create a closure: push a `VmClosure` for the given function index
     MakeClosure(usize),
+    /// Call a closure value sitting just below its `usize` arguments on the stack
+    CallValue(usize),
 
     // Array/Record operations
     /// Create an array from N elements on stack

src/vm/compiler.rs

@@ -570,6 +570,35 @@ impl BytecodeCompiler {
             }
 
             Expr::Call(func_name, args) => {
+                // Built-ins that lower directly to VM opcodes. `Okay(x)`/`Oops(x)`
+                // parse as ordinary calls, so they (and a few stdlib-style ops the
+                // VM already has opcodes for) are recognised here, before the
+                // user-function lookup — mirroring the interpreter's inline
+                // built-in dispatch.
+                if args.len() == 1 {
+                    let unary = match func_name.as_str() {
+                        "Okay" => Some(OpCode::MakeOkay),
+                        "Oops" => Some(OpCode::MakeOops),
+                        "isOkay" => Some(OpCode::IsOkay),
+                        "unwrap" => Some(OpCode::TryUnwrap),
+                        "len" => Some(OpCode::Len),
+                        "toString" => Some(OpCode::ToString),
+                        "print" | "printInline" => Some(OpCode::Print),
+                        _ => None,
+                    };
+                    if let Some(op) = unary {
+                        self.compile_expr(&args[0].node, func)?;
+                        func.emit(op);
+                        return Ok(());
+                    }
+                    if func_name == "isOops" {
+                        self.compile_expr(&args[0].node, func)?;
+                        func.emit(OpCode::IsOkay);
+                        func.emit(OpCode::Not);
+                        return Ok(());
+                    }
+                }
+
                 // Resolve the callee to its function-table index. The arity is
                 // recovered at runtime from the called function's definition.
                 let func_idx = *self
@@ -642,8 +671,8 @@ impl BytecodeCompiler {
                     self.compile_expr(&arg.node, func)?;
                 }
 
-                // Call the closure
-                func.emit(OpCode::Call(args.len()));
+                // Call the closure value (now below its args on the stack).
+                func.emit(OpCode::CallValue(args.len()));
                 Ok(())
             }
 

src/vm/machine.rs

@@ -333,8 +333,9 @@ impl VirtualMachine {
                 }
 
                 OpCode::Print => {
+                    // Use Display (not Debug) to match the interpreter's `print`.
                     let value = self.pop()?;
-                    println!("{:?}", value);
+                    println!("{}", value);
                     self.push(Value::Unit);
                 }
 
@@ -468,11 +469,38 @@ impl VirtualMachine {
                     self.push(Value::Bool(granted));
                 }
 
-                _ => {
-                    return Err(VMError::TypeError(format!(
-                        "Unimplemented opcode: {:?}",
-                        opcode
-                    )));
+                OpCode::MakeClosure(func_idx) => {
+                    // Non-capturing closure: just the bytecode function index.
+                    self.push(Value::VmClosure(func_idx));
+                }
+
+                OpCode::CallValue(argc) => {
+                    // Stack: [callee_closure, arg0, .., arg{argc-1}]. Remove the
+                    // closure from below the args, then enter its frame with the
+                    // args as locals 0..argc.
+                    let cpos = self
+                        .stack
+                        .len()
+                        .checked_sub(argc + 1)
+                        .ok_or(VMError::StackUnderflow)?;
+                    let callee = self.stack.remove(cpos);
+                    let func_idx = match callee {
+                        Value::VmClosure(idx) => idx,
+                        other => {
+                            return Err(VMError::TypeError(format!(
+                                "cannot call non-closure value: {:?}",
+                                other
+                            )))
+                        }
+                    };
+                    if self.program.get_function(func_idx).is_none() {
+                        return Err(VMError::InvalidFunctionIndex(func_idx));
+                    }
+                    self.frames.push(CallFrame {
+                        function_idx: func_idx,
+                        ip: 0,
+                        bp: cpos,
+                    });
                 }
             }
         }

src/vm/mod.rs

@@ -246,4 +246,69 @@ mod tests {
         "#;
         assert_eq!(run_vm(source).unwrap(), Value::Int(99));
     }
+
+    // --- Result constructors + built-ins from surface syntax ---
+
+    #[test]
+    fn test_vm_okay_oops_builtins() {
+        assert_eq!(
+            run_vm(r#"to main() { give back Okay(42); }"#).unwrap(),
+            Value::Okay(Box::new(Value::Int(42)))
+        );
+        assert_eq!(
+            run_vm(r#"to main() { give back Oops(99); }"#).unwrap(),
+            Value::Oops("99".to_string())
+        );
+    }
+
+    #[test]
+    fn test_vm_result_builtins() {
+        assert_eq!(
+            run_vm(r#"to main() { give back isOkay(Okay(1)); }"#).unwrap(),
+            Value::Bool(true)
+        );
+        assert_eq!(
+            run_vm(r#"to main() { give back isOops(Oops(1)); }"#).unwrap(),
+            Value::Bool(true)
+        );
+        assert_eq!(
+            run_vm(r#"to main() { give back unwrap(Okay(5)); }"#).unwrap(),
+            Value::Int(5)
+        );
+    }
+
+    #[test]
+    fn test_vm_len_and_tostring_builtins() {
+        assert_eq!(
+            run_vm(r#"to main() { give back len([1, 2, 3]); }"#).unwrap(),
+            Value::Int(3)
+        );
+        assert_eq!(
+            run_vm(r#"to main() { give back toString(42); }"#).unwrap(),
+            Value::String("42".to_string())
+        );
+    }
+
+    // --- Closures (immediately-invoked lambda via CallExpr) ---
+
+    #[test]
+    fn test_vm_immediately_invoked_lambda() {
+        // (|x| x * 2)(21) -> 42 : MakeClosure + CallValue calling convention.
+        let source = r#"
+            to main() {
+                give back (|x| x * 2)(21);
+            }
+        "#;
+        assert_eq!(run_vm(source).unwrap(), Value::Int(42));
+    }
+
+    #[test]
+    fn test_vm_lambda_two_args() {
+        let source = r#"
+            to main() {
+                give back (|a, b| a + b)(15, 27);
+            }
+        "#;
+        assert_eq!(run_vm(source).unwrap(), Value::Int(42));
+    }
 }