@shd101wyy/yo 0.1.6 → 0.1.8

package/std/process.yo

@@ -66,7 +66,7 @@ extern "Yo",
 // The first element is the program name
 // Example: ["./program", "arg1", "arg2"]
 raw_args :: (fn() -> [*(u8)]) {
-  return __yo_args(:);
+  return __yo_args;
 };
 export raw_args;
 

package/std/regex/compiler.yo

@@ -183,14 +183,14 @@ impl(NfaCompiler,
         right := node.children.get(usize(1)).unwrap();
         split_pc := self._emit(Instr.split_instr(usize(0), usize(0)));
         left_start := self._current_pc();
-        self._program.instructions.set(split_pc, Instr.split_instr(left_start, usize(0)));
+        &(self._program.instructions(split_pc)).* = Instr.split_instr(left_start, usize(0));
         recur(self, left);
         jump_pc := self._emit(Instr.jump_instr(usize(0)));
         right_start := self._current_pc();
-        self._program.instructions.set(split_pc, Instr.split_instr(left_start, right_start));
+        &(self._program.instructions(split_pc)).* = Instr.split_instr(left_start, right_start);
         recur(self, right);
         end_pc := self._current_pc();
-        self._program.instructions.set(jump_pc, Instr.jump_instr(end_pc));
+        &(self._program.instructions(jump_pc)).* = Instr.jump_instr(end_pc);
       },
       .Quantifier => {
         child := node.children.get(usize(0)).unwrap();
@@ -217,10 +217,10 @@ impl(NfaCompiler,
             l3 := self._current_pc();
             cond(
               greedy => {
-                self._program.instructions.set(split_pc, Instr.split_instr(l2, l3));
+                &(self._program.instructions(split_pc)).* = Instr.split_instr(l2, l3);
               },
               true => {
-                self._program.instructions.set(split_pc, Instr.split_instr(l3, l2));
+                &(self._program.instructions(split_pc)).* = Instr.split_instr(l3, l2);
               }
             );
           },
@@ -230,10 +230,10 @@ impl(NfaCompiler,
             l2 := self._current_pc();
             cond(
               greedy => {
-                self._program.instructions.set(split_pc, Instr.split_instr(last_body_start, l2));
+                &(self._program.instructions(split_pc)).* = Instr.split_instr(last_body_start, l2);
               },
               true => {
-                self._program.instructions.set(split_pc, Instr.split_instr(l2, last_body_start));
+                &(self._program.instructions(split_pc)).* = Instr.split_instr(l2, last_body_start);
               }
             );
           },
@@ -248,10 +248,10 @@ impl(NfaCompiler,
               after := self._current_pc();
               cond(
                 greedy => {
-                  self._program.instructions.set(split_pc, Instr.split_instr(body_start, after));
+                  &(self._program.instructions(split_pc)).* = Instr.split_instr(body_start, after);
                 },
                 true => {
-                  self._program.instructions.set(split_pc, Instr.split_instr(after, body_start));
+                  &(self._program.instructions(split_pc)).* = Instr.split_instr(after, body_start);
                 }
               );
             };
@@ -282,7 +282,7 @@ impl(NfaCompiler,
         recur(self, child);
         self._emit(Instr.match_instr());
         sub_end := self._current_pc();
-        self._program.instructions.set(la_pc, Instr.lookahead_instr(sub_start, sub_end, positive));
+        &(self._program.instructions(la_pc)).* = Instr.lookahead_instr(sub_start, sub_end, positive);
       },
       .Lookbehind => {
         child := node.children.get(usize(0)).unwrap();
@@ -292,7 +292,7 @@ impl(NfaCompiler,
         recur(self, child);
         self._emit(Instr.match_instr());
         sub_end := self._current_pc();
-        self._program.instructions.set(lb_pc, Instr.lookbehind_instr(sub_start, sub_end, positive));
+        &(self._program.instructions(lb_pc)).* = Instr.lookbehind_instr(sub_start, sub_end, positive);
       }
     );
   })

package/std/regex/index.yo

@@ -186,11 +186,11 @@ impl(Regex,
   exec : (fn(self : Self, input : String) -> Option(RegexMatch))({
     bytes := input.as_bytes();
     input_len := bytes.len();
+    vm := NfaVm.new(self._program, self._flags, input);
 
     // Sticky flag: only try matching at position 0
     cond(
       self._flags.sticky => {
-        vm := NfaVm.new(self._program, self._flags, input);
         result := vm.exec_at(usize(0));
         cond(
           result.matched => .Some(self._build_match(result.slots, input)),
@@ -205,7 +205,6 @@ impl(Regex,
         );
 
         while (byte_pos <= input_len), {
-          vm := NfaVm.new(self._program, self._flags, input);
           result := vm.exec_at(byte_pos);
 
           cond(
@@ -244,13 +243,13 @@ impl(Regex,
     matches := ArrayList(RegexMatch).new();
     bytes := input.as_bytes();
     input_len := bytes.len();
+    vm := NfaVm.new(self._program, self._flags, input);
 
     cond(
       self._flags.sticky => {
         // Sticky: only try at position 0, then at end of each match
         (byte_pos : usize) = usize(0);
         while (byte_pos <= input_len), {
-          vm := NfaVm.new(self._program, self._flags, input);
           result := vm.exec_at(byte_pos);
 
           cond(
@@ -293,7 +292,6 @@ impl(Regex,
         );
 
         while (byte_pos <= input_len), {
-          vm := NfaVm.new(self._program, self._flags, input);
           result := vm.exec_at(byte_pos);
 
           cond(

package/std/regex/vm.yo

@@ -44,15 +44,6 @@ VmMatch :: struct(
   slots   : ArrayList(usize)
 );
 
-// The NFA virtual machine
-NfaVm :: object(
-  _program   : NfaProgram,
-  _flags     : RegexFlags,
-  _input     : String,
-  _bytes     : ArrayList(u8),
-  _n_slots   : usize
-);
-
 // Helper struct for decoded characters
 DecodedChar :: struct(
   codepoint : u32,
@@ -65,16 +56,34 @@ DeferredThread :: struct(
   thread : NfaThread
 );
 
+// The NFA virtual machine
+NfaVm :: object(
+  _program   : NfaProgram,
+  _flags     : RegexFlags,
+  _input     : String,
+  _bytes     : ArrayList(u8),
+  _n_slots   : usize,
+  _seen      : ArrayList(bool),
+  _next_seen : ArrayList(bool)
+);
+
 // Block 1: Constructor and leaf helpers (no method dependencies)
 impl(NfaVm,
   new : (fn(program : NfaProgram, flags : RegexFlags, input : String) -> Self)({
     n_slots := ((program.n_groups + usize(1)) * usize(2));
+    n_instr := program.instructions.len();
+    seen := ArrayList(bool).with_capacity(n_instr);
+    seen.resize_with_byte(n_instr, int(0));
+    next_seen := ArrayList(bool).with_capacity(n_instr);
+    next_seen.resize_with_byte(n_instr, int(0));
     Self(
       _program: program,
       _flags: flags,
       _input: input,
       _bytes: input.as_bytes(),
-      _n_slots: n_slots
+      _n_slots: n_slots,
+      _seen: seen,
+      _next_seen: next_seen
     )
   }),
 
@@ -231,14 +240,14 @@ impl(NfaVm,
     );
 
     // Already checked bounds above: thread.pc < instructions.len()
-    is_seen := seen.*.get_unchecked(thread.pc);
+    is_seen := (seen.*)(thread.pc);
     cond(
       is_seen => { return (); },
       true => ()
     );
-    seen.*.set_unchecked(thread.pc, true);
+    &((seen.*)(thread.pc)).* = true;
 
-    instr := self._program.instructions.get_unchecked(thread.pc);
+    instr := self._program.instructions(thread.pc);
 
     match(instr.kind,
       .Split => {
@@ -254,7 +263,7 @@ impl(NfaVm,
       .Save => {
         cond(
           (instr.slot < thread.slots.len()) => {
-            thread.slots.set(instr.slot, byte_pos);
+            &(thread.slots(instr.slot)).* = byte_pos;
           },
           true => ()
         );
@@ -420,8 +429,11 @@ impl(NfaVm,
         );
       };
 
+      // Swap sub_current/sub_next and clear for reuse
+      tmp_sub := sub_current;
       sub_current = sub_next;
-      sub_next = ArrayList(NfaThread).new();
+      sub_next = tmp_sub;
+      sub_next.clear();
       sub_pos = (sub_pos + sub_blen);
     };
 
@@ -432,15 +444,16 @@ impl(NfaVm,
 // Block 5: exec_at (depends on Block 1+2+3+4)
 impl(NfaVm,
   exec_at : (fn(self : Self, start_byte : usize) -> VmMatch)({
+    // Reuse pre-allocated seen buffers from the VM
     current := ArrayList(NfaThread).new();
     next := ArrayList(NfaThread).new();
+    seen := self._seen;
+    next_seen := self._next_seen;
     deferred := ArrayList(DeferredThread).new();
 
-    seen := ArrayList(bool).with_capacity(self._program.instructions.len());
-    next_seen := ArrayList(bool).with_capacity(self._program.instructions.len());
-    // Fill with false (0x00) using memset
-    seen.resize_with_byte(self._program.instructions.len(), int(0));
-    next_seen.resize_with_byte(self._program.instructions.len(), int(0));
+    // Clear for this execution
+    seen.fill_with_byte(int(0));
+    next_seen.fill_with_byte(int(0));
 
     initial := NfaThread.new(usize(0), self._n_slots);
     self._add_thread(&(current), initial, start_byte, &(seen));
@@ -701,8 +714,11 @@ impl(NfaVm,
         );
       };
 
+      // Swap current/next and clear for reuse
+      tmp_c := current;
       current = next;
-      next = ArrayList(NfaThread).new();
+      next = tmp_c;
+      next.clear();
 
       cond(
         at_end => { break; },
@@ -712,6 +728,10 @@ impl(NfaVm,
       );
     };
 
+    // Store seen buffers back for reuse in next exec_at call
+    self._seen = seen;
+    self._next_seen = next_seen;
+
     best_match
   })
 );

package/std/string/string.yo

@@ -384,6 +384,29 @@ impl(String,
     );
   }),
 
+  // Clear the string content but keep the allocated buffer for reuse
+  clear : (fn(self: *(Self)) -> unit)(
+    match(self.*._bytes,
+      .Some(al) => al.clear(),
+      .None => ()
+    )
+  ),
+
+  // Create a deep copy of this string with its own buffer
+  clone : (fn(self: Self) -> Self)(
+    match(self._bytes,
+      .None => Self(_bytes: .None),
+      .Some(al) => {
+        (new_al : ArrayList(u8)) = ArrayList(u8).with_capacity(al.len());
+        match(al.ptr(),
+          .Some(p) => new_al.extend_from_ptr(p, al.len()),
+          .None => ()
+        );
+        Self(_bytes: .Some(new_al))
+      }
+    )
+  ),
+
   // Get the number of bytes in the string (not Unicode characters)
   bytes_len : (fn(self: Self) -> usize)(
     match(self._bytes, .Some(b) => b.len(), .None => usize(0))
@@ -415,7 +438,7 @@ impl(String,
             end_byte = byte_index;
             break;
           });
-          (b : u8) = al.get_unchecked(byte_index);
+          (b : u8) = al(byte_index);
           (byte_len : usize) = cond(
             (b < u8(0x80)) => usize(1),
             (b < u8(0xE0)) => usize(2),
@@ -1249,14 +1272,14 @@ impl(String,
 
         (start_idx : usize) = usize(0);
         while (start_idx < total_bytes), {
-          (b : u8) = al.get_unchecked(start_idx);
+          (b : u8) = al(start_idx);
           if(!(Self._is_whitespace_byte(b)), { break; });
           start_idx = (start_idx + usize(1));
         };
 
         (end_idx : usize) = total_bytes;
         while (end_idx > start_idx), {
-          (b : u8) = al.get_unchecked((end_idx - usize(1)));
+          (b : u8) = al((end_idx - usize(1)));
           if(!(Self._is_whitespace_byte(b)), { break; });
           end_idx = (end_idx - usize(1));
         };
@@ -1370,8 +1393,9 @@ impl(String,
   )
 );
 
-impl(String, Add(String, String)(
-  (+) : (fn(self: Self, other: Self) -> Self)({
+impl(String, Add(String)(
+  Output : String,
+  (+) : (fn(self: Self, other: Self) -> Self.Output)({
     return self.concat(other);
   })
 ));
@@ -1886,6 +1910,16 @@ impl(String,
   )
 );
 
+impl(String, Index(usize)(
+  Output : u8,
+  index : (fn(self: *(Self), idx: usize) -> *(Self.Output))(
+    match(self.*._bytes,
+      .Some(bytes) => &(bytes(idx)),
+      .None => panic("String: index on empty string")
+    )
+  )
+));
+
 export
   String,
   StringError,

package/out/types/src/evaluator/calls/array.d.ts

@@ -1,14 +0,0 @@
-import type { Environment } from "../../env";
-import { type Expr, type FnCallExpr } from "../../expr";
-import type { ArrayType, SliceType } from "../../types/definitions";
-import { type ArrayValue, type SliceValue } from "../../value";
-import type { ArrayCallResult, EvaluatorContext } from "../context";
-export declare function tryToCallArrayWithArguments({ expr, arrayType, arrayValue, sliceValue, argExprs, callerEnv, context, }: {
-    expr: FnCallExpr;
-    arrayType: ArrayType | SliceType;
-    arrayValue: ArrayValue | undefined;
-    sliceValue: SliceValue | undefined;
-    argExprs: Expr[];
-    callerEnv: Environment;
-    context: EvaluatorContext;
-}): ArrayCallResult;