Refactor instantiate to return Closure

The `instantiate` method in `Environment` has been refactored to return
`Result<Rc<Closure>, String>` instead of `Rc<NativeFunction>`. This
change separates the creation of a `Closure` from its execution,
allowing the caller to manage the `VM` lifecycle and choose the
appropriate execution strategy (e.g., single run vs. repeated benchmark
iterations).

The `NativeFunction` type is now exclusively used for true Rust
intrinsics. The benchmark runner has also been updated to reuse a single
`VM` across iterations, improving performance by avoiding repeated VM
allocations.

src/ast/environment.rs

@@ -633,55 +633,46 @@ impl Environment {
         Lowering::lower(optimized)
     }
 
-    pub fn instantiate(&self, node: ExecNode) -> Rc<NativeFunction> {
-        let root_values = self.root_values.clone();
-        if let NodeKind::Lambda {
-            params,
-            body,
-            info,
-        } = &node.kind
+    /// Converts a linked `ExecNode` into a callable `Closure`.
+    ///
+    /// Fast path: if the node is already a top-level lambda without upvalues,
+    /// the `Closure` is constructed directly without running the VM.
+    ///
+    /// Slow path: the node is executed once to obtain its resulting `Closure`
+    /// value (e.g. a `do`-block that returns a lambda).
+    ///
+    /// The caller is responsible for creating a `VM` and invoking the closure
+    /// via `vm.run_with_args`. This keeps VM lifecycle and error handling at
+    /// the call site, where the required strategy (single run vs. repeated
+    /// benchmark iterations) is known.
+    pub fn instantiate(&self, node: ExecNode) -> Result<Rc<Closure>, String> {
+        // Fast path: top-level lambda without upvalues — build Closure directly.
+        if let NodeKind::Lambda { params, body, info } = &node.kind
             && info.upvalues.is_empty()
         {
-            let closure = Rc::new(Closure::new(
+            return Ok(Rc::new(Closure::new(
                 params.clone(),
                 body.ty.original.clone(),
                 body.clone(),
                 Vec::new(),
                 info.positional_count,
                 node.ty.stack_size,
-            ));
-            return Rc::new(NativeFunction {
-                purity: Purity::Impure,
-                func: Rc::new(move |args| {
-                    let mut vm = VM::new(root_values.clone());
-                    match vm.run_with_args(closure.clone(), args) {
-                        Ok(v) => v,
-                        Err(e) => panic!("Myc Runtime Error: {}", e),
-                    }
-                }),
-            });
+            )));
         }
 
-        let exec_node = Rc::new(node);
-        Rc::new(NativeFunction {
-            purity: Purity::Impure,
-            func: Rc::new(move |args| {
-                let mut vm = VM::new(root_values.clone());
-                let res = match vm.run(&exec_node) {
-                    Ok(v) => v,
-                    Err(e) => panic!("Myc Runtime Error: {}", e),
-                };
+        // Slow path: run the node once to extract the resulting Closure.
+        let mut vm = VM::new(self.root_values.clone());
+        let res = vm.run(&node)?;
+        if let Value::Closure(obj) = res {
+            Ok(obj)
+        } else {
+            Err("Script did not produce a callable closure".to_string())
+        }
+    }
 
-                if let Value::Closure(obj) = &res {
-                    match vm.run_with_args(obj.clone(), args) {
-                        Ok(v) => v,
-                        Err(e) => panic!("Myc Runtime Error (Closure): {}", e),
-                    }
-                } else {
-                    res
-                }
-            }),
-        })
+    /// Creates a new `VM` connected to this environment's global scope.
+    pub fn create_vm(&self) -> VM {
+        VM::new(self.root_values.clone())
     }
 
     fn specialize_node(&self, node: AnalyzedNode) -> AnalyzedNode {
@@ -780,8 +771,9 @@ impl Environment {
 
     pub fn run_script_compiled(&self, compiled: TypedNode) -> Result<Value, String> {
         let linked = self.link(compiled);
-        let func = self.instantiate(linked);
-        let res = (func.func)(&[]);
+        let closure = self.instantiate(linked)?;
+        let mut vm = self.create_vm();
+        let res = vm.run_with_args(closure, &[])?;
         self.run_pipeline();
         Ok(res)
     }

src/utils/tester.rs

@@ -55,7 +55,7 @@ pub fn run_functional_tests_with_optimization(enabled: bool) -> Vec<TestResult>
     results
 }
 
-pub fn run_benchmarks(update: bool, filter: Option<&str>) -> Vec<BenchmarkResult> {
+pub fn ca(update: bool, filter: Option<&str>) -> Vec<BenchmarkResult> {
     let mut results = Vec::new();
     let entries = fs::read_dir("examples").unwrap();
     let is_release = !cfg!(debug_assertions);
@@ -104,18 +104,19 @@ pub fn run_benchmarks(update: bool, filter: Option<&str>) -> Vec<BenchmarkResult
             }
         };
 
-        // Helper to measure sum of VM execution times over N executions in one environment
+        // Helper to measure sum of VM execution times over N executions in one environment.
+        // A single VM is reused across iterations: run_with_args resets stack/frames
+        // on each call, so no re-allocation is needed between runs.
         let measure_sum =
             |n: u32, node: &TypedNode| -> Result<Duration, String> {
                 let env = Environment::new();
-                
-                // Link once per sample
                 let linked = env.link(node.clone());
-                let func = env.instantiate(linked);
+                let closure = env.instantiate(linked)?;
+                let mut vm = env.create_vm();
                 let mut total = Duration::ZERO;
                 for _ in 0..n {
                     let start = Instant::now();
-                    let _ = (func.func)(&[]);
+                    let _ = vm.run_with_args(closure.clone(), &[])?;
                     total += start.elapsed();
                 }
                 Ok(total)