@shd101wyy/yo 0.1.29 → 0.1.30

package/std/process/command.yo

@@ -9,7 +9,7 @@
 //! { Command } :: import "std/process/command";
 //! { Exception, AnyError } :: import "std/error";
 //!
-//! main :: (fn(io : IO, exn : Exception) -> unit)({
+//! main :: (fn(io : Io, exn : Exception) -> unit)({
 //!   cmd := Command.new(`echo`);
 //!   cmd.arg(`hello`);
 //!   cmd.arg(`world`);
@@ -17,10 +17,11 @@
 //!   assert(out.status.success(), "echo should succeed");
 //! });
 //! ```
+pragma(Pragma.AllowUnsafe);
 open(import("../collections/array_list"));
 open(import("../string"));
-{ Exception, IOErr } :: import("../error");
-{ IOError } :: import("../sys/errors");
+{ Exception, IoExn } :: import("../error");
+{ IoError } :: import("../sys/errors");
 IO_process :: import("../sys/process");
 IO_file :: import("../sys/file");
 IO_pipe :: import("../sys/pipe");
@@ -96,12 +97,12 @@ impl(
     )
   ),
   /// Append a single argument to the argv list.
-  arg : (fn(self : *(Self), a : String) -> unit)({
+  arg : (fn(ref(self) : Self, a : String) -> unit)({
     self._args.push(a);
     ()
   }),
   /// Append multiple arguments to the argv list.
-  args : (fn(self : *(Self), more : ArrayList(String)) -> unit)({
+  args : (fn(ref(self) : Self, more : ArrayList(String)) -> unit)({
     n := more.len();
     i := usize(0);
     while(runtime(i < n), {
@@ -122,7 +123,7 @@ impl(
 // Convert each entry of `(program + args)` into an owned NUL-terminated
 // `ArrayList(u8)`. The returned list owns the C-string storage; callers
 // extract the raw `*(u8)` pointers separately.
-_build_cstr_storage :: (fn(self : *(Command)) -> ArrayList(ArrayList(u8)))({
+_build_cstr_storage :: (fn(self : Command) -> ArrayList(ArrayList(u8)))({
   storage := ArrayList(ArrayList(u8)).new();
   storage.push(self._program.to_cstr());
   n := self._args.len();
@@ -145,15 +146,20 @@ _build_cstr_storage :: (fn(self : *(Command)) -> ArrayList(ArrayList(u8)))({
 // returns the pid (since the kernel reads argv synchronously inside the syscall).
 _spawn_with_fds :: (
   fn(
-    self : *(Command),
+    self : Command,
     stdin_fd : i32,
     stdout_fd : i32,
     stderr_fd : i32,
-    io : IO
-  ) -> Impl(Future(i32, IOErr))
-)(
+    io : Io
+  ) -> Impl(Future(i32, IoExn))
+)({
+  // Build the C-string storage BEFORE entering the async closure so the
+  // closure doesn't have to capture `self` directly. `self : Command` is an
+  // object/ref binding that can't be safely captured across an async
+  // boundary; the resulting `storage` ArrayList is Rc/heap-allocated and
+  // can be moved into the closure's capture struct.
+  storage := _build_cstr_storage(self);
   io.async((e) => {
-    storage := _build_cstr_storage(self);
     argc := storage.len();
     // Allocate argv buffer: argc entries + 1 null terminator.
     argv_bytes := (sizeof(?*(u8)) * (argc + usize(1)));
@@ -185,12 +191,12 @@ _spawn_with_fds :: (
     pid := e.io.await(IO_process.spawn(program_cstr, argv_buf,.None, stdin_fd, stdout_fd, stderr_fd), e.io);
     // Free argv buffer (storage is dropped naturally at scope end).
     free(.Some(argv_raw));
-    IOError.check(pid, e.exn)
+    IoError.check(pid, e.exn)
   })
-);
+});
 // Read all available bytes from `fd` into a freshly returned ArrayList(u8)
 // until EOF (read returns 0).
-_drain_fd :: (fn(fd : i32, io : IO) -> Impl(Future(ArrayList(u8), IOErr)))(
+_drain_fd :: (fn(fd : i32, io : Io) -> Impl(Future(ArrayList(u8), IoExn)))(
   io.async((e) => {
     buf_size := usize(4096);
     buf := *(u8)(malloc(buf_size).unwrap());
@@ -200,7 +206,7 @@ _drain_fd :: (fn(fd : i32, io : IO) -> Impl(Future(ArrayList(u8), IOErr)))(
       cond(
         (n < i32(0)) => {
           free(.Some(*(void)(buf)));
-          e.exn.throw(dyn(IOError.from_errno(i32(0) - n)));
+          e.exn.throw(dyn(IoError.from_errno(i32(0) - n)));
         },
         (n == i32(0)) => break,
         true => {
@@ -223,24 +229,32 @@ impl(
   Command,
   /// Spawn the child with stdio inherited from the parent, wait for it to
   /// exit, and return its `ExitStatus`.
-  status : (fn(self : *(Self), io : IO) -> Impl(Future(ExitStatus, IOErr)))(
+  status : (fn(self : Self, io : Io) -> Impl(Future(ExitStatus, IoExn)))(
+    // `self : Self` is a value-copy of the Rc-counted Command object, so the
+    // closure can freely capture it. (Was `ref(self)` previously, which is a
+    // second-class reference and can't be captured across an async boundary.)
     io.async((e) => {
-      pid := e.io.await(_spawn_with_fds(self, i32(-(1)), i32(-(1)), i32(-(1)), io), e);
+      pid := e.io.await(
+        _spawn_with_fds(self, i32(-(1)), i32(-(1)), i32(-(1)), io),
+        e
+      );
       raw := e.io.await(IO_process.waitpid(pid, i32(0)), e.io);
-      IOError.check(raw, e.exn);
+      IoError.check(raw, e.exn);
       ExitStatus(raw : raw)
     })
   ),
   /// Spawn the child with stdout and stderr captured through pipes. Waits for
   /// the child to exit and returns the exit status plus the captured bytes.
-  output : (fn(self : *(Self), io : IO) -> Impl(Future(Output, IOErr)))(
+  output : (fn(self : Self, io : Io) -> Impl(Future(Output, IoExn)))(
+    // `self : Self` is a value-copy of the Rc-counted Command object; the
+    // closure can freely capture it instead of needing `ref(self)`.
     io.async((e) => {
       // Create stdout and stderr pipes.
       out_fd_buf := MaybeUninit(Array(i32, usize(2))).new();
       out_fd := *(i32)(out_fd_buf.as_ptr());
       pr1 := IO_pipe.pipe(out_fd);
       cond(
-        (pr1 < i32(0)) => e.exn.throw(dyn(IOError.from_errno(i32(0) - pr1))),
+        (pr1 < i32(0)) => e.exn.throw(dyn(IoError.from_errno(i32(0) - pr1))),
         true => ()
       );
       out_read := (out_fd &+ usize(0)).*;
@@ -252,14 +266,17 @@ impl(
         (pr2 < i32(0)) => {
           e.io.await(IO_file.close(out_read), e.io);
           e.io.await(IO_file.close(out_write), e.io);
-          e.exn.throw(dyn(IOError.from_errno(i32(0) - pr2)));
+          e.exn.throw(dyn(IoError.from_errno(i32(0) - pr2)));
         },
         true => ()
       );
       err_read := (err_fd &+ usize(0)).*;
       err_write := (err_fd &+ usize(1)).*;
       // Spawn child with the write ends of both pipes.
-      pid := e.io.await(_spawn_with_fds(self, i32(-(1)), out_write, err_write, io), e);
+      pid := e.io.await(
+        _spawn_with_fds(self, i32(-(1)), out_write, err_write, io),
+        e
+      );
       // Close write ends in parent so reads see EOF when child exits.
       e.io.await(IO_file.close(out_write), e.io);
       e.io.await(IO_file.close(err_write), e.io);
@@ -269,7 +286,7 @@ impl(
       e.io.await(IO_file.close(out_read), e.io);
       e.io.await(IO_file.close(err_read), e.io);
       raw := e.io.await(IO_process.waitpid(pid, i32(0)), e.io);
-      IOError.check(raw, e.exn);
+      IoError.check(raw, e.exn);
       Output(
         status : ExitStatus(raw : raw),
         stdout : stdout_buf,

package/std/process/index.yo

@@ -2,6 +2,7 @@
 //!
 //! Environment variables, command-line arguments, and current working
 //! directory live in `std/env`.
+pragma(Pragma.AllowUnsafe);
 /// Current target platform as a compile-time string.
 /// One of: "linux", "macos", "windows", "freebsd", "emscripten", "wasi".
 platform :: __yo_process_platform();
@@ -19,7 +20,7 @@ export(Arch);
 /// Exit the process with the given status code.
 exit :: (fn(code : usize) -> unit)({
   { exit : _exit } :: import("../libc/stdlib");
-  _exit(int(code));
+  unsafe(_exit(int(code)));
 });
 export(exit);
 _command :: import("./command.yo");

package/std/regex/compiler.yo

@@ -1,5 +1,6 @@
 //! NFA compiler — compiles a `RegexNode` AST into a flat list of NFA instructions
 //! using Thompson's construction algorithm.
+pragma(Pragma.AllowUnsafe);
 open(import("std/collections/array_list"));
 open(import("std/string"));
 { RegexNode, NodeKind, CharRange, AnchorKind, GroupNameEntry } :: import("./node.yo");
@@ -269,13 +270,13 @@ impl(
       .Sequence => {
         i := usize(0);
         while(i < node.children.len(), i = (i + usize(1)), {
-          child := node.children.get(i).unwrap();
+          child := node.children(i);
           recur(self, child);
         });
       },
       .Alternation => {
-        left := node.children.get(usize(0)).unwrap();
-        right := node.children.get(usize(1)).unwrap();
+        left := node.children(usize(0));
+        right := node.children(usize(1));
         split_pc := self._emit(Instr.split_instr(usize(0), usize(0)));
         left_start := self._current_pc();
         &(self._program.instructions(split_pc)).* = Instr.split_instr(left_start, usize(0));
@@ -288,7 +289,7 @@ impl(
         &(self._program.instructions(jump_pc)).* = Instr.jump_instr(end_pc);
       },
       .Quantifier => {
-        child := node.children.get(usize(0)).unwrap();
+        child := node.children(usize(0));
         min_val := node.q_min;
         max_val := node.q_max;
         greedy := node.q_greedy;
@@ -352,7 +353,7 @@ impl(
         );
       },
       .Group => {
-        child := node.children.get(usize(0)).unwrap();
+        child := node.children(usize(0));
         start_slot := (node.group_index * usize(2));
         end_slot := ((node.group_index * usize(2)) + usize(1));
         self._emit(Instr.save_instr(start_slot));
@@ -360,14 +361,14 @@ impl(
         self._emit(Instr.save_instr(end_slot));
       },
       .NonCapturingGroup => {
-        child := node.children.get(usize(0)).unwrap();
+        child := node.children(usize(0));
         recur(self, child);
       },
       .Backreference => {
         self._emit(Instr.backref_instr(node.group_index));
       },
       .Lookahead => {
-        child := node.children.get(usize(0)).unwrap();
+        child := node.children(usize(0));
         positive := (!(node.negated));
         // Emit lookahead instruction with placeholder sub_end
         la_pc := self._emit(Instr.lookahead_instr(usize(0), usize(0), positive));
@@ -378,7 +379,7 @@ impl(
         &(self._program.instructions(la_pc)).* = Instr.lookahead_instr(sub_start, sub_end, positive);
       },
       .Lookbehind => {
-        child := node.children.get(usize(0)).unwrap();
+        child := node.children(usize(0));
         positive := (!(node.negated));
         lb_pc := self._emit(Instr.lookbehind_instr(usize(0), usize(0), positive));
         sub_start := self._current_pc();
@@ -401,7 +402,7 @@ impl(
     instrs := self._program.instructions;
     (done : bool) = false;
     while((pc < instrs.len()) && (!(done)), {
-      instr := instrs.get(pc).unwrap();
+      instr := instrs(pc);
       match(
         instr.kind,
         .Save => {

package/std/regex/index.yo

@@ -61,7 +61,7 @@ impl(
     result_bytes := ArrayList(u8).with_capacity(end_pos - start);
     i := start;
     while(i < end_pos, i = (i + usize(1)), {
-      result_bytes.push(bytes.get(i).unwrap());
+      result_bytes.push(bytes(i));
     });
     String.from_bytes(result_bytes)
   }),
@@ -69,7 +69,7 @@ impl(
     char_idx := usize(0);
     i := usize(0);
     while(i < byte_pos, {
-      b := bytes.get(i).unwrap();
+      b := bytes(i);
       char_len := cond(
         (b < u8(0x80)) => usize(1),
         ((b >= u8(0xC0)) && (b < u8(0xE0))) => usize(2),
@@ -91,18 +91,18 @@ impl(
       (prefix_len == usize(0)) => from_byte,
       (input_len < prefix_len) => (input_len + usize(1)),
       true => {
-        first_byte := prefix.get(usize(0)).unwrap();
+        first_byte := prefix(usize(0));
         (pos : usize) = from_byte;
         (found : bool) = false;
         while((pos <= (input_len - prefix_len)) && (!(found)), {
           cond(
-            (input_bytes.get(pos).unwrap() == first_byte) => {
+            (input_bytes(pos) == first_byte) => {
               // Check remaining prefix bytes
               (match_ok : bool) = true;
               pi := usize(1);
               while((pi < prefix_len) && match_ok, pi = (pi + usize(1)), {
                 cond(
-                  (input_bytes.get(pos + pi).unwrap() != prefix.get(pi).unwrap()) => {
+                  (input_bytes(pos + pi) != prefix(pi)) => {
                     match_ok = false;
                   },
                   true => ()
@@ -136,8 +136,8 @@ impl(
   _build_match : (fn(self : Self, slots : ArrayList(usize), input : String) -> RegexMatch)({
     bytes := input.as_bytes();
     unset := usize.MAX;
-    match_start_byte := slots.get(usize(0)).unwrap();
-    match_end_byte := slots.get(usize(1)).unwrap();
+    match_start_byte := slots(usize(0));
+    match_end_byte := slots(usize(1));
     match_text := self._extract_substring(bytes, match_start_byte, match_end_byte);
     match_char_index := self._byte_to_char_index(bytes, match_start_byte);
     groups := ArrayList(Option(String)).new();
@@ -147,8 +147,8 @@ impl(
       end_slot := ((g * usize(2)) + usize(1));
       cond(
         ((start_slot < slots.len()) && (end_slot < slots.len())) => {
-          gs := slots.get(start_slot).unwrap();
-          ge := slots.get(end_slot).unwrap();
+          gs := slots(start_slot);
+          ge := slots(end_slot);
           cond(
             ((gs != unset) && (ge != unset)) => {
               group_text := self._extract_substring(bytes, gs, ge);
@@ -203,7 +203,7 @@ impl(
               break;
             },
             true => {
-              b := bytes.get(byte_pos).unwrap();
+              b := bytes(byte_pos);
               char_len := cond(
                 (b < u8(0x80)) => usize(1),
                 ((b >= u8(0xC0)) && (b < u8(0xE0))) => usize(2),
@@ -237,8 +237,8 @@ impl(
             result.matched => {
               m := self._build_match(result.slots, input);
               matches.push(m);
-              match_start := result.slots.get(usize(0)).unwrap();
-              match_end := result.slots.get(usize(1)).unwrap();
+              match_start := result.slots(usize(0));
+              match_end := result.slots(usize(1));
               cond(
                 (match_end == match_start) => {
                   // Empty match: advance one char to avoid infinite loop
@@ -247,7 +247,7 @@ impl(
                       break;
                     },
                     true => {
-                      b := bytes.get(byte_pos).unwrap();
+                      b := bytes(byte_pos);
                       char_len := cond(
                         (b < u8(0x80)) => usize(1),
                         ((b >= u8(0xC0)) && (b < u8(0xE0))) => usize(2),
@@ -281,8 +281,8 @@ impl(
             result.matched => {
               m := self._build_match(result.slots, input);
               matches.push(m);
-              match_start := result.slots.get(usize(0)).unwrap();
-              match_end := result.slots.get(usize(1)).unwrap();
+              match_start := result.slots(usize(0));
+              match_end := result.slots(usize(1));
               cond(
                 (match_end == match_start) => {
                   cond(
@@ -290,7 +290,7 @@ impl(
                       break;
                     },
                     true => {
-                      b := bytes.get(byte_pos).unwrap();
+                      b := bytes(byte_pos);
                       char_len := cond(
                         (b < u8(0x80)) => usize(1),
                         ((b >= u8(0xC0)) && (b < u8(0xE0))) => usize(2),
@@ -319,7 +319,7 @@ impl(
                   break;
                 },
                 true => {
-                  b := bytes.get(byte_pos).unwrap();
+                  b := bytes(byte_pos);
                   char_len := cond(
                     (b < u8(0x80)) => usize(1),
                     ((b >= u8(0xC0)) && (b < u8(0xE0))) => usize(2),
@@ -368,11 +368,11 @@ impl(
     result := ArrayList(u8).new();
     i := usize(0);
     while(i < rep_len, {
-      b := rep_bytes.get(i).unwrap();
+      b := rep_bytes(i);
       cond(
         ((b == u8(36)) && ((i + usize(1)) < rep_len)) => {
           // '$' character — check next char
-          next_b := rep_bytes.get(i + usize(1)).unwrap();
+          next_b := rep_bytes(i + usize(1));
           cond(
             (next_b == u8(36)) => {
               // $$ → literal $
@@ -384,7 +384,7 @@ impl(
               match_bytes := m.value().as_bytes();
               mi := usize(0);
               while(mi < match_bytes.len(), mi = (mi + usize(1)), {
-                result.push(match_bytes.get(mi).unwrap());
+                result.push(match_bytes(mi));
               });
               i = (i + usize(2));
             },
@@ -396,7 +396,7 @@ impl(
               byte_idx := usize(0);
               ci := usize(0);
               while(ci < char_idx, {
-                cb := input_bytes.get(byte_idx).unwrap();
+                cb := input_bytes(byte_idx);
                 cbl := cond(
                   (cb < u8(0x80)) => usize(1),
                   ((cb >= u8(0xC0)) && (cb < u8(0xE0))) => usize(2),
@@ -408,7 +408,7 @@ impl(
               });
               pi := usize(0);
               while(pi < byte_idx, pi = (pi + usize(1)), {
-                result.push(input_bytes.get(pi).unwrap());
+                result.push(input_bytes(pi));
               });
               i = (i + usize(2));
             },
@@ -420,7 +420,7 @@ impl(
               byte_idx := usize(0);
               ci := usize(0);
               while(ci < char_idx, {
-                cb := input_bytes.get(byte_idx).unwrap();
+                cb := input_bytes(byte_idx);
                 cbl := cond(
                   (cb < u8(0x80)) => usize(1),
                   ((cb >= u8(0xC0)) && (cb < u8(0xE0))) => usize(2),
@@ -435,7 +435,7 @@ impl(
               byte_idx = (byte_idx + match_bytes.len());
               pi := byte_idx;
               while(pi < input_bytes.len(), pi = (pi + usize(1)), {
-                result.push(input_bytes.get(pi).unwrap());
+                result.push(input_bytes(pi));
               });
               i = (i + usize(2));
             },
@@ -449,7 +449,7 @@ impl(
                   g_bytes := g.as_bytes();
                   gi := usize(0);
                   while(gi < g_bytes.len(), gi = (gi + usize(1)), {
-                    result.push(g_bytes.get(gi).unwrap());
+                    result.push(g_bytes(gi));
                   });
                 },
                 .None => ()
@@ -462,7 +462,7 @@ impl(
               (name_end : usize) = name_start;
               (found_close : bool) = false;
               while(name_end < rep_len, {
-                nb := rep_bytes.get(name_end).unwrap();
+                nb := rep_bytes(name_end);
                 cond(
                   (nb == u8(125)) => {
                     found_close = true;
@@ -478,7 +478,7 @@ impl(
                   name_bytes := ArrayList(u8).with_capacity(name_end - name_start);
                   ni := name_start;
                   while(ni < name_end, ni = (ni + usize(1)), {
-                    name_bytes.push(rep_bytes.get(ni).unwrap());
+                    name_bytes.push(rep_bytes(ni));
                   });
                   name := String.from_bytes(name_bytes);
                   grp := m.named_group(name);
@@ -488,7 +488,7 @@ impl(
                       g_bytes := g.as_bytes();
                       gi := usize(0);
                       while(gi < g_bytes.len(), gi = (gi + usize(1)), {
-                        result.push(g_bytes.get(gi).unwrap());
+                        result.push(g_bytes(gi));
                       });
                     },
                     .None => ()
@@ -533,7 +533,7 @@ impl(
         (match_start_byte : usize) = usize(0);
         ci := usize(0);
         while(ci < char_idx, {
-          cb := input_bytes.get(match_start_byte).unwrap();
+          cb := input_bytes(match_start_byte);
           cbl := cond(
             (cb < u8(0x80)) => usize(1),
             ((cb >= u8(0xC0)) && (cb < u8(0xE0))) => usize(2),
@@ -548,17 +548,17 @@ impl(
         out := ArrayList(u8).new();
         pi := usize(0);
         while(pi < match_start_byte, pi = (pi + usize(1)), {
-          out.push(input_bytes.get(pi).unwrap());
+          out.push(input_bytes(pi));
         });
         rep := self._apply_replacement(replacement, m);
         rep_bytes := rep.as_bytes();
         ri := usize(0);
         while(ri < rep_bytes.len(), ri = (ri + usize(1)), {
-          out.push(rep_bytes.get(ri).unwrap());
+          out.push(rep_bytes(ri));
         });
         pi = match_end_byte;
         while(pi < input_bytes.len(), pi = (pi + usize(1)), {
-          out.push(input_bytes.get(pi).unwrap());
+          out.push(input_bytes(pi));
         });
         String.from_bytes(out)
       }
@@ -574,13 +574,13 @@ impl(
         (last_end_byte : usize) = usize(0);
         mi := usize(0);
         while(mi < all_matches.len(), mi = (mi + usize(1)), {
-          m := all_matches.get(mi).unwrap();
+          m := all_matches(mi);
           // Convert char index to byte index for match start
           char_idx := m.index();
           (match_start_byte : usize) = usize(0);
           ci := usize(0);
           while(ci < char_idx, {
-            cb := input_bytes.get(match_start_byte).unwrap();
+            cb := input_bytes(match_start_byte);
             cbl := cond(
               (cb < u8(0x80)) => usize(1),
               ((cb >= u8(0xC0)) && (cb < u8(0xE0))) => usize(2),
@@ -594,21 +594,21 @@ impl(
           // Copy text between last match end and this match start
           pi := last_end_byte;
           while(pi < match_start_byte, pi = (pi + usize(1)), {
-            out.push(input_bytes.get(pi).unwrap());
+            out.push(input_bytes(pi));
           });
           // Apply replacement
           rep := self._apply_replacement(replacement, m);
           rep_bytes := rep.as_bytes();
           ri := usize(0);
           while(ri < rep_bytes.len(), ri = (ri + usize(1)), {
-            out.push(rep_bytes.get(ri).unwrap());
+            out.push(rep_bytes(ri));
           });
           last_end_byte = match_end_byte;
         });
         // Copy remaining text after last match
         pi := last_end_byte;
         while(pi < input_bytes.len(), pi = (pi + usize(1)), {
-          out.push(input_bytes.get(pi).unwrap());
+          out.push(input_bytes(pi));
         });
         String.from_bytes(out)
       }
@@ -626,13 +626,13 @@ impl(
         (last_end_byte : usize) = usize(0);
         mi := usize(0);
         while(mi < all_matches.len(), mi = (mi + usize(1)), {
-          m := all_matches.get(mi).unwrap();
+          m := all_matches(mi);
           // Convert char index to byte index for match start
           char_idx := m.index();
           (match_start_byte : usize) = usize(0);
           ci := usize(0);
           while(ci < char_idx, {
-            cb := input_bytes.get(match_start_byte).unwrap();
+            cb := input_bytes(match_start_byte);
             cbl := cond(
               (cb < u8(0x80)) => usize(1),
               ((cb >= u8(0xC0)) && (cb < u8(0xE0))) => usize(2),
@@ -647,7 +647,7 @@ impl(
           part_bytes := ArrayList(u8).new();
           pi := last_end_byte;
           while(pi < match_start_byte, pi = (pi + usize(1)), {
-            part_bytes.push(input_bytes.get(pi).unwrap());
+            part_bytes.push(input_bytes(pi));
           });
           parts.push(String.from_bytes(part_bytes));
           // Include capture groups in split result (like JS)
@@ -670,7 +670,7 @@ impl(
         remaining := ArrayList(u8).new();
         pi := last_end_byte;
         while(pi < input_bytes.len(), pi = (pi + usize(1)), {
-          remaining.push(input_bytes.get(pi).unwrap());
+          remaining.push(input_bytes(pi));
         });
         parts.push(String.from_bytes(remaining));
       }

package/std/regex/match.yo

@@ -42,7 +42,7 @@ impl(
       true => {
         actual_idx := (idx - usize(1));
         cond(
-          (actual_idx < self._groups.len()) => self._groups.get(actual_idx).unwrap(),
+          (actual_idx < self._groups.len()) => self._groups(actual_idx),
           true =>.None
         )
       }
@@ -52,7 +52,7 @@ impl(
   named_group : (fn(self : Self, name : String) -> Option(String))({
     i := usize(0);
     while(i < self._group_names.len(), i = (i + usize(1)), {
-      entry := self._group_names.get(i).unwrap();
+      entry := self._group_names(i);
       cond(
         (entry.name == name) => {
           return(self.group(entry.index));