Add Arena struct with thread-local

Add TAG_ARENA NaN-boxing tag to distinguish arena values from Rc
Arena values have free clone (just copy bits) and no-op drop
Add Value::promote to convert arena values to Rc when escaping scope

Author: 0xhenrique

src/lib.rs

@@ -10,21 +10,31 @@ pub use compiler::Compiler;
 pub use eval::{eval, standard_env, Env};
 pub use macros::{expand, MacroRegistry};
 pub use parser::{parse, parse_all};
-pub use value::Value;
+pub use value::{clear_arena, set_arena_enabled, Value};
 pub use vm::{standard_vm, VM};
 
 /// Convenience function to evaluate a string using the bytecode VM
 pub fn run(input: &str) -> Result<Value, String> {
     let expr = parse(input)?;
     let chunk = Compiler::compile(&expr)?;
     let mut vm = standard_vm();
-    vm.run(chunk)
+    let result = vm.run(chunk)?;
+    // Promote result to Rc if needed (escaping arena scope)
+    let promoted = result.promote();
+    // Clear arena after each expression
+    clear_arena();
+    Ok(promoted)
 }
 
 /// Convenience function to evaluate multiple expressions using the bytecode VM
 pub fn run_all(input: &str) -> Result<Value, String> {
     let exprs = parse_all(input)?;
     let chunk = Compiler::compile_all(&exprs)?;
     let mut vm = standard_vm();
-    vm.run(chunk)
+    let result = vm.run(chunk)?;
+    // Promote result to Rc if needed (escaping arena scope)
+    let promoted = result.promote();
+    // Clear arena after execution
+    clear_arena();
+    Ok(promoted)
 }

src/main.rs

@@ -1,4 +1,4 @@
-use lisp_vm::{expand, parse, parse_all, standard_env, standard_vm, Compiler, MacroRegistry, Value};
+use lisp_vm::{clear_arena, expand, parse, parse_all, standard_env, standard_vm, Compiler, MacroRegistry, Value};
 use std::env;
 use std::fs;
 use std::io::{self, BufRead, Write};
@@ -41,8 +41,18 @@ fn run_file(filename: &str) -> Result<Value, String> {
     let chunk = Compiler::compile_all(&expanded)?;
 
     // Execute via bytecode VM
+    // Note: Arena allocations accumulate during execution for maximum performance
+    // (free clone/drop). The arena is cleared when the program exits.
     let mut vm = standard_vm();
-    vm.run(chunk)
+    let result = vm.run(chunk)?;
+
+    // Promote result if it contains arena values (for returning to caller)
+    let promoted = result.promote();
+
+    // Clear arena after execution (frees all temporary allocations at once)
+    clear_arena();
+
+    Ok(promoted)
 }
 
 fn run_repl() {
@@ -88,12 +98,19 @@ fn run_repl() {
                                         // Execute via VM
                                         match vm.run(chunk) {
                                             Ok(result) => {
+                                                // Promote result before displaying (escapes arena)
+                                                let result = result.promote();
                                                 // Don't display nil results (common REPL behavior)
                                                 if !result.is_nil() {
                                                     println!("{}", result);
                                                 }
+                                                // Clear arena after each REPL command
+                                                clear_arena();
+                                            }
+                                            Err(e) => {
+                                                clear_arena(); // Clear even on error
+                                                eprintln!("Error: {}", e);
                                             }
-                                            Err(e) => eprintln!("Error: {}", e),
                                         }
                                     }
                                     Err(e) => eprintln!("Compile error: {}", e),