Update benchmark metadata

This commit updates the benchmark metadata in several example files. The
benchmark runs and repeat counts have been slightly adjusted due to
optimizations or minor variations in execution.

examples/closure.myc

@@ -1,6 +1,6 @@
 ;; Closure Scope Test
-;; Benchmark: 777ns
+;; Benchmark: 779ns
-;; Benchmark-Repeat: 2659
+;; Benchmark-Repeat: 2613
 ;; Output: 15
 (do
   (def make-adder (fn [x] 

examples/closure_cracking.myc

@@ -1,2 +1,4 @@
+;; Benchmark: 143ns
+;; Benchmark-Repeat: 14093
 ;; Output: 5
 (((fn [x] (fn [] x)) 5))

examples/closure_cracking_named.myc

@@ -1,3 +1,5 @@
+;; Benchmark: 620ns
+;; Benchmark-Repeat: 3234
 ;; Output: 5
 (do
     (def f (fn [x] (fn [] x)))

examples/currying.myc

@@ -1,3 +1,5 @@
+;; Benchmark: 1.1us
+;; Benchmark-Repeat: 1848
 ;; Output: 42
 (do
     (def f (fn [a] (fn [b] (fn [c] (+ a (+ b c))))))

examples/data.myc

@@ -1,5 +1,5 @@
 ;; Complex Data Structure Test
-;; Benchmark: 53.1us
+;; Benchmark: 53.6us
 ;; Benchmark-Repeat: 39
 ;; Output: {:name "Fibonacci", :input 10, :output 55}
 (do

examples/def_local_inlining.myc

@@ -1,3 +1,5 @@
+;; Benchmark: 363ns
+;; Benchmark-Repeat: 5561
 ;; examples/def_local_inlining.myc
 ;; Demonstrates potential for DefLocal-Inlining (Phase 2.5)
 

examples/destructuring.myc

@@ -1,5 +1,5 @@
-;; Benchmark: 2.3us
+;; Benchmark: 2.4us
-;; Benchmark-Repeat: 880
+;; Benchmark-Repeat: 848
 ;; Comprehensive Destructuring Test
 ;; Covers: Nested tuples, mixed params, dynamic passing
 

examples/extreme_capture.myc

@@ -1,5 +1,5 @@
-;; Benchmark: 1.7us
+;; Benchmark: 1.4us
-;; Benchmark-Repeat: 1198
+;; Benchmark-Repeat: 1448
 ;; Output: 36
 (do
   ;; Excessive capture test

examples/fib.myc

@@ -1,6 +1,6 @@
 ;; Fibonacci Recursive
-;; Benchmark: 52.5us
+;; Benchmark: 53.7us
-;; Benchmark-Repeat: 38
+;; Benchmark-Repeat: 39
 ;; Output: 55
 (do
   (def fib (fn [n]

examples/folding.myc

@@ -1,2 +1,4 @@
+;; Benchmark: 143ns
+;; Benchmark-Repeat: 14112
 ;; Output: 30
 (+ 10 20)

examples/hof.myc

@@ -1,6 +1,6 @@
 ;; Higher-Order Function Example
-;; Benchmark: 680ns
+;; Benchmark: 706ns
-;; Benchmark-Repeat: 2981
+;; Benchmark-Repeat: 2798
 ;; Output: 25
 (do
   (def apply (fn [f x] (f x)))

examples/macro_financial.myc

@@ -1,5 +1,5 @@
-;; Benchmark: 462ns
+;; Benchmark: 354ns
-;; Benchmark-Repeat: 4348
+;; Benchmark-Repeat: 5640
 ;; Financial DSL Macro example
 ;; Demonstrates generating complex records from simple parameters.
 ;; Output: {:price 100, :size 2, :total 200}

examples/macro_hygiene.myc

@@ -1,5 +1,5 @@
-;; Benchmark: 350ns
+;; Benchmark: 339ns
-;; Benchmark-Repeat: 5767
+;; Benchmark-Repeat: 6100
 ;; Output: 5
 (do
 (def y 1)

examples/macro_power.myc

@@ -1,5 +1,5 @@
-;; Benchmark: 376ns
+;; Benchmark: 217ns
-;; Benchmark-Repeat: 5359
+;; Benchmark-Repeat: 9500
 ;; Nested Macro and Arithmetic example
 ;; Output: 81
 

examples/macro_splice.myc

@@ -1,5 +1,5 @@
-;; Benchmark: 277ns
+;; Benchmark: 259ns
-;; Benchmark-Repeat: 7185
+;; Benchmark-Repeat: 7947
 ;; Macro Splicing example
 ;; Demonstrates unrolling a list into another list.
 ;; Output: [0 1 2 3 4]

examples/macro_unless.myc

@@ -1,5 +1,5 @@
-;; Benchmark: 177ns
+;; Benchmark: 146ns
-;; Benchmark-Repeat: 11587
+;; Benchmark-Repeat: 14044
 ;; Classic "unless" macro example
 ;; Demonstrates simple template substitution.
 ;; Output: 42

examples/optimizer_purity.myc

@@ -1,3 +1,5 @@
+;; Benchmark: 503ns
+;; Benchmark-Repeat: 3987
 (do
   (def PI 3.1415)
   (def area (fn [x] (* PI x)))

examples/record_to_tuple.myc

@@ -1,7 +1,7 @@
 ;; Record to Tuple Mapping Test
 ;; Output: 30
-;; Benchmark: 743ns
+;; Benchmark: 760ns
-;; Benchmark-Repeat: 2733
+;; Benchmark-Repeat: 2612
 (do
   (def rec {:x 10 :y 20})
   

examples/record_unpack.myc

@@ -2,8 +2,8 @@
 ;; This test calls a function that destructures a record
 ;; Current implementation is now zero-allocation for destructuring.
 ;; Output: 3
-;; Benchmark: 723ns
+;; Benchmark: 740ns
-;; Benchmark-Repeat: 2783
+;; Benchmark-Repeat: 2745
 
 (do
   (def process (fn [[x y]] 

examples/tak.myc

@@ -2,8 +2,8 @@
 ;; heavily recursive, benefits significantly from specialization of integer arithmetic
 ;; and direct function calls (skipping dynamic dispatch).
 ;; Output: 5
-
+
-;; Benchmark: 471.9us
+;; Benchmark: 488.0us
 ;; Benchmark-Repeat: 5
 
 (do

examples/tco_test.myc

@@ -1,4 +1,4 @@
-;; Benchmark: 2.7ms
+;; Benchmark: 2.9ms
 ;; Output: "done"
 (do
   (def count_down (fn [n]

examples/tuples.myc

@@ -1,5 +1,5 @@
 ;; Benchmark: 1.9us
-;; Benchmark-Repeat: 1061
+;; Benchmark-Repeat: 1043
 ;; Demonstration of N-dimensional Tuples, Vectors, and Matrices
 ;; Based on docs/Tupel 1.md
 ;;

src/ast/compiler/snapshots/myc__ast__compiler__optimizer__tests__opt_assignment_safety.snap

@@ -1,9 +1,14 @@
 ---
 source: src/ast/compiler/optimizer.rs
-assertion_line: 533
+assertion_line: 720
 expression: dump
 ---
 Lambda (Upvalues: 0) <Metadata: Metadata { ty: Function(Signature { params: Tuple([]), ret: Int }), is_tail: true }>
   Parameters:
   Tuple <Metadata: Metadata { ty: Tuple([]), is_tail: false }>
-  Constant: 20 <Metadata: Metadata { ty: Int, is_tail: true }>
+  Block <Metadata: Metadata { ty: Int, is_tail: true }>
+    DefLocal (Name: 'x', Slot: 0, not captured) <Metadata: Metadata { ty: Int, is_tail: false }>
+      Constant: 10 <Metadata: Metadata { ty: Int, is_tail: false }>
+    Set: Local(0) <Metadata: Metadata { ty: Int, is_tail: false }>
+      Constant: 20 <Metadata: Metadata { ty: Int, is_tail: false }>
+    Constant: 20 <Metadata: Metadata { ty: Int, is_tail: true }>

src/ast/compiler/snapshots/myc__ast__compiler__optimizer__tests__opt_lambda_cracking.snap

@@ -1,16 +1,12 @@
 ---
 source: src/ast/compiler/optimizer.rs
-assertion_line: 540
+assertion_line: 727
 expression: dump
 ---
 Lambda (Upvalues: 0) <Metadata: Metadata { ty: Function(Signature { params: Tuple([]), ret: Function(Signature { params: Tuple([]), ret: Int }) }), is_tail: true }>
   Parameters:
   Tuple <Metadata: Metadata { ty: Tuple([]), is_tail: false }>
-  Block <Metadata: Metadata { ty: Function(Signature { params: Tuple([]), ret: Int }), is_tail: true }>
+  Lambda (Upvalues: 0) <Metadata: Metadata { ty: Function(Signature { params: Tuple([]), ret: Int }), is_tail: true }>
-    DefLocal (Name: 'x', Slot: 0, captured by 1 lambdas) <Metadata: Metadata { ty: Int, is_tail: false }>
+    Parameters:
-      - Capturer: Lambda at line 1, col 23
+    Tuple <Metadata: Metadata { ty: Tuple([]), is_tail: false }>
-      Constant: 10 <Metadata: Metadata { ty: Int, is_tail: false }>
+    Constant: 10 <Metadata: Metadata { ty: Int, is_tail: true }>
-    Lambda (Upvalues: 0) <Metadata: Metadata { ty: Function(Signature { params: Tuple([]), ret: Int }), is_tail: true }>
-      Parameters:
-      Tuple <Metadata: Metadata { ty: Tuple([]), is_tail: false }>
-      Constant: 10 <Metadata: Metadata { ty: Int, is_tail: true }>

src/integration_test.rs

@@ -1,9 +1,9 @@
 #[cfg(test)]
 mod tests {
+    use crate::ast::environment::Environment;
+    use crate::ast::nodes::UntypedKind;
     use crate::ast::parser::Parser;
     use crate::ast::types::Value;
-    use crate::ast::nodes::UntypedKind;
-    use crate::ast::environment::Environment;
 
     #[test]
     fn test_parse_integer_constant() {
@@ -85,14 +85,19 @@ mod tests {
         for level in 0..=2 {
             let results = crate::utils::tester::run_functional_tests_with_level(level);
             for res in results {
-                assert!(res.success, "Example {} failed at level {}: {}", res.name, level, res.message);
+                assert!(
+                    res.success,
+                    "Example {} failed at level {}: {}",
+                    res.name, level, res.message
+                );
             }
         }
     }
 
     #[test]
     fn test_debug_mode_logging() {
-        let env = Environment::new();
+        let mut env = Environment::new();
+        env.optimization_level = 0;
         let source = "(+ 10 20)";
         let result = env.run_debug(source).expect("Failed to run debug");
 
@@ -130,10 +135,22 @@ mod tests {
         assert_eq!(format!("{}", env.run_script("(% 20 3)").unwrap()), "2"); // 20 % 3 = 2
 
         // --- Logic / Bitwise ---
-        assert_eq!(format!("{}", env.run_script("(and true false)").unwrap()), "false");
+        assert_eq!(
-        assert_eq!(format!("{}", env.run_script("(or true false)").unwrap()), "true");
+            format!("{}", env.run_script("(and true false)").unwrap()),
-        assert_eq!(format!("{}", env.run_script("(xor true false)").unwrap()), "true");
+            "false"
-        assert_eq!(format!("{}", env.run_script("(not true)").unwrap()), "false");
+        );
+        assert_eq!(
+            format!("{}", env.run_script("(or true false)").unwrap()),
+            "true"
+        );
+        assert_eq!(
+            format!("{}", env.run_script("(xor true false)").unwrap()),
+            "true"
+        );
+        assert_eq!(
+            format!("{}", env.run_script("(not true)").unwrap()),
+            "false"
+        );
 
         assert_eq!(format!("{}", env.run_script("(<< 1 2)").unwrap()), "4"); // 1 << 2 = 4
         assert_eq!(format!("{}", env.run_script("(>> 4 1)").unwrap()), "2"); // 4 >> 1 = 2
@@ -174,7 +191,7 @@ mod tests {
 
         let result = env.run_script(source);
         if let Err(e) = &result {
-             panic!("Failed: {}", e);
+            panic!("Failed: {}", e);
         }
         assert_eq!(format!("{}", result.unwrap()), "60");
     }