@shd101wyy/yo 0.1.26 → 0.1.27

package/std/regex/parser.yo

@@ -1,54 +1,49 @@
 //! Regex pattern parser — parses a regex pattern string into an AST
 //! of `RegexNode` objects. Uses an iterative stack-based approach.
-
-open import "std/collections/array_list";
-open import "std/string";
-{ RegexNode, NodeKind, CharRange, AnchorKind, GroupNameEntry } :: import "./node.yo";
-{ unicode_property_ranges } :: import "./unicode.yo";
-
+open(import("std/collections/array_list"));
+open(import("std/string"));
+{ RegexNode, NodeKind, CharRange, AnchorKind, GroupNameEntry } :: import("./node.yo");
+{ unicode_property_ranges } :: import("./unicode.yo");
 // A parse frame for tracking alternation/sequence state
 ParseFrame :: struct(
   alternatives : ArrayList(ArrayList(RegexNode)),
-  current      : ArrayList(RegexNode),
+  current : ArrayList(RegexNode),
   is_non_capturing : bool,
-  group_index  : usize,
-  is_lookahead  : bool,
+  group_index : usize,
+  is_lookahead : bool,
   is_lookbehind : bool,
-  is_positive   : bool
+  is_positive : bool
 );
-
 // Parser state object
 RegexParser :: object(
-  _source      : String,
-  _bytes       : ArrayList(u8),
-  _pos         : usize,
+  _source : String,
+  _bytes : ArrayList(u8),
+  _pos : usize,
   _group_count : usize,
   _group_names : ArrayList(GroupNameEntry)
 );
-
 // First impl block: utility + leaf parsers (defined bottom-up)
-impl(RegexParser,
+impl(
+  RegexParser,
   new : (fn(pattern : String) -> Self)(
     Self(
-      _source: pattern,
-      _bytes: pattern.as_bytes(),
-      _pos: usize(0),
-      _group_count: usize(0),
-      _group_names: ArrayList(GroupNameEntry).new()
+      _source : pattern,
+      _bytes : pattern.as_bytes(),
+      _pos : usize(0),
+      _group_count : usize(0),
+      _group_names : ArrayList(GroupNameEntry).new()
     )
   ),
-
   _peek : (fn(self : Self) -> Option(u8))(
     cond(
       (self._pos < self._bytes.len()) => self._bytes.get(self._pos),
-      true => .None
+      true =>.None
     )
   ),
-
   _advance : (fn(self : Self) -> Option(u8))({
     cond(
       (self._pos >= self._bytes.len()) => {
-        return .None;
+        return(.None);
       },
       true => ()
     );
@@ -56,7 +51,6 @@ impl(RegexParser,
     self._pos = (self._pos + usize(1));
     b
   }),
-
   // Decode a full UTF-8 codepoint given the first byte (already consumed by _advance).
   // Reads 0-3 continuation bytes from self._pos and advances past them.
   _read_codepoint : (fn(self : Self, first : u8) -> u32)(
@@ -65,48 +59,45 @@ impl(RegexParser,
       ((first >= u8(0xC0)) && (first < u8(0xE0))) => {
         second := self._bytes.get(self._pos).unwrap();
         self._pos = (self._pos + usize(1));
-        (((u32(first) & u32(0x1F)) << u32(6)) | (u32(second) & u32(0x3F)))
+        ((u32(first) & u32(0x1F)) << u32(6)) | (u32(second) & u32(0x3F))
       },
       ((first >= u8(0xE0)) && (first < u8(0xF0))) => {
         second := self._bytes.get(self._pos).unwrap();
-        third := self._bytes.get((self._pos + usize(1))).unwrap();
+        third := self._bytes.get(self._pos + usize(1)).unwrap();
         self._pos = (self._pos + usize(2));
-        ((((u32(first) & u32(0x0F)) << u32(12)) | ((u32(second) & u32(0x3F)) << u32(6))) | (u32(third) & u32(0x3F)))
+        (((u32(first) & u32(0x0F)) << u32(12)) | ((u32(second) & u32(0x3F)) << u32(6))) | (u32(third) & u32(0x3F))
       },
       true => {
         second := self._bytes.get(self._pos).unwrap();
-        third := self._bytes.get((self._pos + usize(1))).unwrap();
-        fourth := self._bytes.get((self._pos + usize(2))).unwrap();
+        third := self._bytes.get(self._pos + usize(1)).unwrap();
+        fourth := self._bytes.get(self._pos + usize(2)).unwrap();
         self._pos = (self._pos + usize(3));
-        (((((u32(first) & u32(0x07)) << u32(18)) | ((u32(second) & u32(0x3F)) << u32(12))) | ((u32(third) & u32(0x3F)) << u32(6))) | (u32(fourth) & u32(0x3F)))
+        ((((u32(first) & u32(0x07)) << u32(18)) | ((u32(second) & u32(0x3F)) << u32(12))) | ((u32(third) & u32(0x3F)) << u32(6))) | (u32(fourth) & u32(0x3F))
       }
     )
   ),
-
   _at_end : (fn(self : Self) -> bool)(
-    (self._pos >= self._bytes.len())
+    self._pos >= self._bytes.len()
   ),
-
   group_count : (fn(self : Self) -> usize)(
     self._group_count
   ),
-
   group_names : (fn(self : Self) -> ArrayList(GroupNameEntry))(
     self._group_names
   ),
-
   _lookup_group_name : (fn(self : Self, name : String) -> Option(usize))({
     i := usize(0);
-    while (i < self._group_names.len()), (i = (i + usize(1))), {
+    while(i < self._group_names.len(), i = (i + usize(1)), {
       entry := self._group_names.get(i).unwrap();
       cond(
-        (entry.name == name) => { return .Some(entry.index); },
+        (entry.name == name) => {
+          return(.Some(entry.index));
+        },
         true => ()
       );
-    };
+    });
     .None
   }),
-
   _escape_char_codepoint : (fn(self : Self, ch : u8) -> u32)(
     cond(
       (ch == u8(110)) => u32(10),
@@ -114,16 +105,16 @@ impl(RegexParser,
       (ch == u8(114)) => u32(13),
       (ch == u8(102)) => u32(12),
       (ch == u8(118)) => u32(11),
-      (ch == u8(48))  => u32(0),
+      (ch == u8(48)) => u32(0),
       true => u32(ch)
     )
   ),
-
   _parse_number : (fn(self : Self) -> Option(usize))({
     start := self._pos;
-    while (!(self._at_end())), {
+    while(!(self._at_end()), {
       pk := self._peek();
-      is_digit := match(pk,
+      is_digit := match(
+        pk,
         .Some(b) => ((b >= u8(48)) && (b <= u8(57))),
         .None => false
       );
@@ -131,135 +122,140 @@ impl(RegexParser,
         is_digit => {
           self._pos = (self._pos + usize(1));
         },
-        true => { break; }
+        true => {
+          break;
+        }
       );
-    };
+    });
     cond(
       (self._pos == start) => {
-        return .None;
+        return(.None);
       },
       true => ()
     );
     result := usize(0);
     i := start;
-    while (i < self._pos), (i = (i + usize(1))), {
+    while(i < self._pos, i = (i + usize(1)), {
       d := self._bytes.get(i).unwrap();
-      result = ((result * usize(10)) + usize((d - u8(48))));
-    };
+      result = ((result * usize(10)) + usize(d - u8(48)));
+    });
     .Some(result)
   }),
-
   _parse_greedy_modifier : (fn(self : Self) -> bool)({
     pk := self._peek();
-    is_question := match(pk,
+    is_question := match(
+      pk,
       .Some(b) => (b == u8(63)),
       .None => false
     );
     cond(
       is_question => {
         self._pos = (self._pos + usize(1));
-        return false;
+        return(false);
       },
       true => ()
     );
     true
   }),
-
   _make_digit_ranges : (fn(self : Self) -> ArrayList(CharRange))({
     r := ArrayList(CharRange).new();
-    r.push(CharRange(low: u32(48), high: u32(57)));
+    r.push(CharRange(low : u32(48), high : u32(57)));
     r
   }),
-
   _make_word_ranges : (fn(self : Self) -> ArrayList(CharRange))({
     r := ArrayList(CharRange).new();
-    r.push(CharRange(low: u32(48), high: u32(57)));
-    r.push(CharRange(low: u32(65), high: u32(90)));
-    r.push(CharRange(low: u32(95), high: u32(95)));
-    r.push(CharRange(low: u32(97), high: u32(122)));
+    r.push(CharRange(low : u32(48), high : u32(57)));
+    r.push(CharRange(low : u32(65), high : u32(90)));
+    r.push(CharRange(low : u32(95), high : u32(95)));
+    r.push(CharRange(low : u32(97), high : u32(122)));
     r
   }),
-
   _make_space_ranges : (fn(self : Self) -> ArrayList(CharRange))({
     r := ArrayList(CharRange).new();
-    r.push(CharRange(low: u32(9), high: u32(13)));
-    r.push(CharRange(low: u32(32), high: u32(32)));
+    r.push(CharRange(low : u32(9), high : u32(13)));
+    r.push(CharRange(low : u32(32), high : u32(32)));
     r
   }),
-
   // Parse \xHH hex escape — reads exactly 2 hex digits and returns the codepoint.
   _parse_hex_byte : (fn(self : Self) -> Option(u32))({
-    if(((self._pos + usize(2)) > self._bytes.len()), { return .None; });
+    if((self._pos + usize(2)) > self._bytes.len(), {
+      return(.None);
+    });
     (h1 : u8) = self._bytes.get(self._pos).unwrap();
-    (h2 : u8) = self._bytes.get((self._pos + usize(1))).unwrap();
+    (h2 : u8) = self._bytes.get(self._pos + usize(1)).unwrap();
     (v1 : i32) = cond(
       ((h1 >= u8(48)) && (h1 <= u8(57))) => (i32(h1) - i32(48)),
       ((h1 >= u8(65)) && (h1 <= u8(70))) => ((i32(h1) - i32(65)) + i32(10)),
       ((h1 >= u8(97)) && (h1 <= u8(102))) => ((i32(h1) - i32(97)) + i32(10)),
-      true => { return .None; }
+      true => {
+        return(.None);
+      }
     );
     (v2 : i32) = cond(
       ((h2 >= u8(48)) && (h2 <= u8(57))) => (i32(h2) - i32(48)),
       ((h2 >= u8(65)) && (h2 <= u8(70))) => ((i32(h2) - i32(65)) + i32(10)),
       ((h2 >= u8(97)) && (h2 <= u8(102))) => ((i32(h2) - i32(97)) + i32(10)),
-      true => { return .None; }
+      true => {
+        return(.None);
+      }
     );
     self._pos = (self._pos + usize(2));
-    .Some(u32(((v1 << i32(4)) | v2)))
+    .Some(u32((v1 << i32(4)) | v2))
   }),
-
   _parse_class_escape : (fn(self : Self) -> Result(ArrayList(CharRange), String))({
     b := self._advance();
-    match(b,
+    match(
+      b,
       .Some(ch) =>
         cond(
-          (ch == u8(100)) => .Ok(self._make_digit_ranges()),
+          (ch == u8(100)) =>.Ok(self._make_digit_ranges()),
           (ch == u8(68)) => {
             r := ArrayList(CharRange).new();
-            r.push(CharRange(low: u32(0), high: u32(47)));
-            r.push(CharRange(low: u32(58), high: u32(0x10FFFF)));
+            r.push(CharRange(low : u32(0), high : u32(47)));
+            r.push(CharRange(low : u32(58), high : u32(0x10FFFF)));
             .Ok(r)
           },
-          (ch == u8(119)) => .Ok(self._make_word_ranges()),
+          (ch == u8(119)) =>.Ok(self._make_word_ranges()),
           (ch == u8(87)) => {
             r := ArrayList(CharRange).new();
-            r.push(CharRange(low: u32(0), high: u32(47)));
-            r.push(CharRange(low: u32(58), high: u32(64)));
-            r.push(CharRange(low: u32(91), high: u32(94)));
-            r.push(CharRange(low: u32(96), high: u32(96)));
-            r.push(CharRange(low: u32(123), high: u32(0x10FFFF)));
+            r.push(CharRange(low : u32(0), high : u32(47)));
+            r.push(CharRange(low : u32(58), high : u32(64)));
+            r.push(CharRange(low : u32(91), high : u32(94)));
+            r.push(CharRange(low : u32(96), high : u32(96)));
+            r.push(CharRange(low : u32(123), high : u32(0x10FFFF)));
             .Ok(r)
           },
-          (ch == u8(115)) => .Ok(self._make_space_ranges()),
+          (ch == u8(115)) =>.Ok(self._make_space_ranges()),
           (ch == u8(83)) => {
             r := ArrayList(CharRange).new();
-            r.push(CharRange(low: u32(0), high: u32(8)));
-            r.push(CharRange(low: u32(14), high: u32(31)));
-            r.push(CharRange(low: u32(33), high: u32(0x10FFFF)));
+            r.push(CharRange(low : u32(0), high : u32(8)));
+            r.push(CharRange(low : u32(14), high : u32(31)));
+            r.push(CharRange(low : u32(33), high : u32(0x10FFFF)));
             .Ok(r)
           },
           (ch == u8(120)) => {
             r := ArrayList(CharRange).new();
-            match(self._parse_hex_byte(),
-              .Some(v) => r.push(CharRange(low: v, high: v)),
-              .None => r.push(CharRange(low: u32(ch), high: u32(ch)))
+            match(
+              self._parse_hex_byte(),
+              .Some(v) => r.push(CharRange(low : v, high : v)),
+              .None => r.push(CharRange(low : u32(ch), high : u32(ch)))
             );
             .Ok(r)
           },
           true => {
             r := ArrayList(CharRange).new();
             codepoint := self._escape_char_codepoint(ch);
-            r.push(CharRange(low: codepoint, high: codepoint));
+            r.push(CharRange(low : codepoint, high : codepoint));
             .Ok(r)
           }
         ),
-      .None => .Err(`Unexpected end of pattern after backslash`)
+      .None =>.Err(`Unexpected end of pattern after backslash`)
     )
   }),
-
   _try_parse_char_range : (fn(self : Self, ranges : ArrayList(CharRange), low : u32) -> unit)({
     pk3 := self._peek();
-    is_dash := match(pk3,
+    is_dash := match(
+      pk3,
       .Some(b2) => (b2 == u8(45)),
       .None => false
     );
@@ -268,33 +264,34 @@ impl(RegexParser,
         has_end := ((self._pos + usize(1)) < self._bytes.len());
         cond(
           has_end => {
-            end_first := self._bytes.get((self._pos + usize(1))).unwrap();
+            end_first := self._bytes.get(self._pos + usize(1)).unwrap();
             cond(
               (end_first == u8(93)) => {
-                ranges.push(CharRange(low: low, high: low));
+                ranges.push(CharRange(low : low, high : low));
               },
               (end_first == u8(92)) => {
                 // High end is an escape sequence (e.g. \x20, \0, \n)
                 self._pos = (self._pos + usize(1));
                 self._pos = (self._pos + usize(1));
                 esc := self._parse_class_escape();
-                match(esc,
+                match(
+                  esc,
                   .Ok(esc_ranges) => {
-                    if(((esc_ranges.len() == usize(1)) && (esc_ranges.get(usize(0)).unwrap().low == esc_ranges.get(usize(0)).unwrap().high)), {
+                    if((esc_ranges.len() == usize(1)) && (esc_ranges.get(usize(0)).unwrap().low == esc_ranges.get(usize(0)).unwrap().high), {
                       (high : u32) = esc_ranges.get(usize(0)).unwrap().low;
-                      ranges.push(CharRange(low: low, high: high));
+                      ranges.push(CharRange(low : low, high : high));
                     }, {
                       // Multi-range escape like \d can't be range endpoint; treat dash as literal
-                      ranges.push(CharRange(low: low, high: low));
-                      ranges.push(CharRange(low: u32(45), high: u32(45)));
+                      ranges.push(CharRange(low : low, high : low));
+                      ranges.push(CharRange(low : u32(45), high : u32(45)));
                       j := usize(0);
-                      while (j < esc_ranges.len()), (j = (j + usize(1))), {
+                      while(j < esc_ranges.len(), j = (j + usize(1)), {
                         ranges.push(esc_ranges.get(j).unwrap());
-                      };
+                      });
                     });
                   },
                   .Err(_e) => {
-                    ranges.push(CharRange(low: low, high: low));
+                    ranges.push(CharRange(low : low, high : low));
                   }
                 );
               },
@@ -305,49 +302,53 @@ impl(RegexParser,
                 self._pos = (self._pos + usize(1));
                 // Decode full codepoint (reads continuation bytes)
                 end_cp := self._read_codepoint(end_first);
-                ranges.push(CharRange(low: low, high: end_cp));
+                ranges.push(CharRange(low : low, high : end_cp));
               }
             );
           },
           true => {
-            ranges.push(CharRange(low: low, high: low));
+            ranges.push(CharRange(low : low, high : low));
           }
         );
       },
       true => {
-        ranges.push(CharRange(low: low, high: low));
+        ranges.push(CharRange(low : low, high : low));
       }
     );
   }),
-
   _parse_char_class_content : (fn(self : Self, ranges : ArrayList(CharRange)) -> Result(unit, String))({
     pk2 := self._peek();
-    b := match(pk2,
+    b := match(
+      pk2,
       .Some(v) => v,
-      .None => { return .Err(`Unterminated character class`); }
+      .None => {
+        return(.Err(`Unterminated character class`));
+      }
     );
-
     cond(
       (b == u8(93)) => {
-        return .Ok(());
+        return(.Ok(()));
       },
       (b == u8(92)) => {
         self._pos = (self._pos + usize(1));
         esc := self._parse_class_escape();
-        match(esc,
+        match(
+          esc,
           .Ok(esc_ranges) => {
             // If escape produced a single codepoint, check for range (e.g. \0-\x20)
-            if(((esc_ranges.len() == usize(1)) && (esc_ranges.get(usize(0)).unwrap().low == esc_ranges.get(usize(0)).unwrap().high)), {
+            if((esc_ranges.len() == usize(1)) && (esc_ranges.get(usize(0)).unwrap().low == esc_ranges.get(usize(0)).unwrap().high), {
               (low : u32) = esc_ranges.get(usize(0)).unwrap().low;
               self._try_parse_char_range(ranges, low);
             }, {
               j := usize(0);
-              while (j < esc_ranges.len()), (j = (j + usize(1))), {
+              while(j < esc_ranges.len(), j = (j + usize(1)), {
                 ranges.push(esc_ranges.get(j).unwrap());
-              };
+              });
             });
           },
-          .Err(e) => { return .Err(e); }
+          .Err(e) => {
+            return(.Err(e));
+          }
         );
       },
       true => {
@@ -358,14 +359,13 @@ impl(RegexParser,
     );
     .Ok(())
   }),
-
   _parse_char_class : (fn(self : Self) -> Result(RegexNode, String))({
     ranges := ArrayList(CharRange).new();
     negated := false;
-
     // Check for negation '^'
     pk := self._peek();
-    is_neg := match(pk,
+    is_neg := match(
+      pk,
       .Some(b) => (b == u8(94)),
       .None => false
     );
@@ -376,64 +376,71 @@ impl(RegexParser,
       },
       true => ()
     );
-
     // Parse class contents until ']'
-    while (!(self._at_end())), {
+    while(!(self._at_end()), {
       pk2 := self._peek();
-      found_end := match(pk2,
+      found_end := match(
+        pk2,
         .Some(b) => (b == u8(93)),
         .None => false
       );
       cond(
         found_end => {
           self._pos = (self._pos + usize(1));
-          return .Ok(RegexNode.char_class(ranges, negated));
+          return(.Ok(RegexNode.char_class(ranges, negated)));
         },
         true => ()
       );
-
       result := self._parse_char_class_content(ranges);
-      match(result,
+      match(
+        result,
         .Ok(_) => (),
-        .Err(e) => { return .Err(e); }
+        .Err(e) => {
+          return(.Err(e));
+        }
       );
-    };
+    });
     .Err(`Unterminated character class`)
   }),
-
   // Parse \p{PropertyName} or \P{PropertyName} unicode property escape.
   // negated=true for \P (inverted match).
   _parse_unicode_property : (fn(self : Self, negated : bool) -> Result(RegexNode, String))({
     // Expect opening '{'
     pk := self._peek();
-    is_brace := match(pk,
+    is_brace := match(
+      pk,
       .Some(v) => (v == u8(123)),
       .None => false
     );
     cond(
       (!(is_brace)) => {
-        return .Err(`Expected '{' after \\p or \\P`);
+        return(.Err(`Expected '{' after \\p or \\P`));
       },
       true => ()
     );
     self._pos = (self._pos + usize(1));
-
     // Read property name until '}'
     name_bytes := ArrayList(u8).new();
-    while (!(self._at_end())), {
+    while(!(self._at_end()), {
       nb := self._peek();
-      nb_val := match(nb,
+      nb_val := match(
+        nb,
         .Some(v) => v,
-        .None => { break; }
+        .None => {
+          break;
+        }
       );
       cond(
         (nb_val == u8(125)) => {
           self._pos = (self._pos + usize(1));
           name_str := String.from_bytes(name_bytes);
           lookup := unicode_property_ranges(name_str);
-          return match(lookup,
-            .Some(ranges) => .Ok(RegexNode.char_class(ranges, negated)),
-            .None => .Err(`Unknown Unicode property: \\p{${name_str}}`)
+          return(
+            match(
+              lookup,
+              .Some(ranges) =>.Ok(RegexNode.char_class(ranges, negated)),
+              .None =>.Err(`Unknown Unicode property: \\p{${name_str}}`)
+            )
           );
         },
         true => {
@@ -441,61 +448,68 @@ impl(RegexParser,
           self._pos = (self._pos + usize(1));
         }
       );
-    };
+    });
     .Err(`Unterminated Unicode property \\p{...}`)
   }),
-
   _parse_escape : (fn(self : Self) -> Result(RegexNode, String))({
     b := self._advance();
-    match(b,
+    match(
+      b,
       .Some(ch) =>
         cond(
-          (ch == u8(100)) => .Ok(RegexNode.char_class(self._make_digit_ranges(), false)),
-          (ch == u8(68)) => .Ok(RegexNode.char_class(self._make_digit_ranges(), true)),
-          (ch == u8(119)) => .Ok(RegexNode.char_class(self._make_word_ranges(), false)),
-          (ch == u8(87)) => .Ok(RegexNode.char_class(self._make_word_ranges(), true)),
-          (ch == u8(115)) => .Ok(RegexNode.char_class(self._make_space_ranges(), false)),
-          (ch == u8(83)) => .Ok(RegexNode.char_class(self._make_space_ranges(), true)),
-          (ch == u8(98)) => .Ok(RegexNode.anchor_node(.WordBoundary)),
-          (ch == u8(66)) => .Ok(RegexNode.anchor_node(.NonWordBoundary)),
+          (ch == u8(100)) =>.Ok(RegexNode.char_class(self._make_digit_ranges(), false)),
+          (ch == u8(68)) =>.Ok(RegexNode.char_class(self._make_digit_ranges(), true)),
+          (ch == u8(119)) =>.Ok(RegexNode.char_class(self._make_word_ranges(), false)),
+          (ch == u8(87)) =>.Ok(RegexNode.char_class(self._make_word_ranges(), true)),
+          (ch == u8(115)) =>.Ok(RegexNode.char_class(self._make_space_ranges(), false)),
+          (ch == u8(83)) =>.Ok(RegexNode.char_class(self._make_space_ranges(), true)),
+          (ch == u8(98)) =>.Ok(RegexNode.anchor_node(.WordBoundary)),
+          (ch == u8(66)) =>.Ok(RegexNode.anchor_node(.NonWordBoundary)),
           // Numeric backreference \1 through \9
           ((ch >= u8(49)) && (ch <= u8(57))) => {
-            group_idx := usize((ch - u8(48)));
+            group_idx := usize(ch - u8(48));
             cond(
               (group_idx > self._group_count) =>
                 .Err(`Backreference \\${group_idx} exceeds number of groups`),
-              true => .Ok(RegexNode.backreference(group_idx))
+              true =>.Ok(RegexNode.backreference(group_idx))
             )
           },
           // Named backreference \k<name>
           (ch == u8(107)) => {
             pk := self._peek();
-            is_lt := match(pk,
+            is_lt := match(
+              pk,
               .Some(v) => (v == u8(60)),
               .None => false
             );
             cond(
               (!(is_lt)) => {
-                return .Err(`Expected '<' after \\k`);
+                return(.Err(`Expected '<' after \\k`));
               },
               true => ()
             );
             self._pos = (self._pos + usize(1));
             name_bytes := ArrayList(u8).new();
-            while (!(self._at_end())), {
+            while(!(self._at_end()), {
               nb := self._peek();
-              nb_val := match(nb,
+              nb_val := match(
+                nb,
                 .Some(v) => v,
-                .None => { break; }
+                .None => {
+                  break;
+                }
               );
               cond(
                 (nb_val == u8(62)) => {
                   self._pos = (self._pos + usize(1));
                   name_str := String.from_bytes(name_bytes);
                   lookup := self._lookup_group_name(name_str);
-                  return match(lookup,
-                    .Some(idx) => .Ok(RegexNode.backreference(idx)),
-                    .None => .Err(`Unknown named group in backreference`)
+                  return(
+                    match(
+                      lookup,
+                      .Some(idx) =>.Ok(RegexNode.backreference(idx)),
+                      .None =>.Err(`Unknown named group in backreference`)
+                    )
                   );
                 },
                 true => {
@@ -503,7 +517,7 @@ impl(RegexParser,
                   self._pos = (self._pos + usize(1));
                 }
               );
-            };
+            });
             .Err(`Unterminated named backreference \\k<...>`)
           },
           // Unicode property \p{Name}
@@ -511,117 +525,123 @@ impl(RegexParser,
           // Negated unicode property \P{Name}
           (ch == u8(80)) => self._parse_unicode_property(true),
           // Hex escape \xHH
-          (ch == u8(120)) => match(self._parse_hex_byte(),
-            .Some(v) => .Ok(RegexNode.literal(v)),
-            .None => .Ok(RegexNode.literal(u32(ch)))
+          (ch == u8(120)) => match(
+            self._parse_hex_byte(),
+            .Some(v) =>.Ok(RegexNode.literal(v)),
+            .None =>.Ok(RegexNode.literal(u32(ch)))
           ),
-          true => .Ok(RegexNode.literal(self._escape_char_codepoint(ch)))
+          true =>.Ok(RegexNode.literal(self._escape_char_codepoint(ch)))
         ),
-      .None => .Err(`Unexpected end of pattern after backslash`)
+      .None =>.Err(`Unexpected end of pattern after backslash`)
     )
   }),
-
   _parse_counted_quantifier : (fn(self : Self, atom : RegexNode) -> Result(RegexNode, String))({
     self._pos = (self._pos + usize(1));
     min_opt := self._parse_number();
-    mn := match(min_opt,
+    mn := match(
+      min_opt,
       .Some(v) => v,
-      .None => { return .Err(`Expected number after '{'`); }
+      .None => {
+        return(.Err(`Expected number after '{'`));
+      }
     );
-
     pk := self._peek();
-    b := match(pk,
+    b := match(
+      pk,
       .Some(v) => v,
-      .None => { return .Err(`Unexpected end of pattern in quantifier`); }
+      .None => {
+        return(.Err(`Unexpected end of pattern in quantifier`));
+      }
     );
-
     cond(
       (b == u8(125)) => {
         // {n}
         self._pos = (self._pos + usize(1));
         greedy := self._parse_greedy_modifier();
-        return .Ok(RegexNode.quantifier(atom, mn, mn, greedy));
+        return(.Ok(RegexNode.quantifier(atom, mn, mn, greedy)));
       },
       (b != u8(44)) => {
-        return .Err(`Expected ',' or '}' in quantifier`);
+        return(.Err(`Expected ',' or '}' in quantifier`));
       },
       true => ()
     );
-
     // Consume ','
     self._pos = (self._pos + usize(1));
-
     pk2 := self._peek();
-    b2 := match(pk2,
+    b2 := match(
+      pk2,
       .Some(v) => v,
-      .None => { return .Err(`Unexpected end of pattern in quantifier`); }
+      .None => {
+        return(.Err(`Unexpected end of pattern in quantifier`));
+      }
     );
-
     cond(
       (b2 == u8(125)) => {
         // {n,} — unbounded
         self._pos = (self._pos + usize(1));
         greedy := self._parse_greedy_modifier();
-        return .Ok(RegexNode.quantifier(atom, mn, usize(0), greedy));
+        return(.Ok(RegexNode.quantifier(atom, mn, usize(0), greedy)));
       },
       true => ()
     );
-
     // {n,m}
     max_opt := self._parse_number();
-    mx := match(max_opt,
+    mx := match(
+      max_opt,
       .Some(v) => v,
-      .None => { return .Err(`Expected number after ',' in quantifier`); }
+      .None => {
+        return(.Err(`Expected number after ',' in quantifier`));
+      }
     );
-
     pk3 := self._peek();
-    b3 := match(pk3,
+    b3 := match(
+      pk3,
       .Some(v) => v,
-      .None => { return .Err(`Unexpected end of pattern in quantifier`); }
+      .None => {
+        return(.Err(`Unexpected end of pattern in quantifier`));
+      }
     );
-
     cond(
       (b3 != u8(125)) => {
-        return .Err(`Expected '}' in quantifier`);
+        return(.Err(`Expected '}' in quantifier`));
       },
       true => ()
     );
     self._pos = (self._pos + usize(1));
-
     cond(
       (mx < mn) => {
-        return .Err(`Invalid quantifier: max less than min`);
+        return(.Err(`Invalid quantifier: max less than min`));
       },
       true => ()
     );
-
     greedy := self._parse_greedy_modifier();
     .Ok(RegexNode.quantifier(atom, mn, mx, greedy))
   }),
-
   _parse_atom : (fn(self : Self) -> Result(RegexNode, String))({
     b := self._advance();
-    match(b,
+    match(
+      b,
       .Some(ch) =>
         cond(
-          (ch == u8(46)) => .Ok(RegexNode.dot()),
-          (ch == u8(94)) => .Ok(RegexNode.anchor_node(.Start)),
-          (ch == u8(36)) => .Ok(RegexNode.anchor_node(.End)),
+          (ch == u8(46)) =>.Ok(RegexNode.dot()),
+          (ch == u8(94)) =>.Ok(RegexNode.anchor_node(.Start)),
+          (ch == u8(36)) =>.Ok(RegexNode.anchor_node(.End)),
           (ch == u8(91)) => self._parse_char_class(),
           (ch == u8(92)) => self._parse_escape(),
-          true => .Ok(RegexNode.literal(self._read_codepoint(ch)))
+          true =>.Ok(RegexNode.literal(self._read_codepoint(ch)))
         ),
-      .None => .Err(`Unexpected end of pattern`)
+      .None =>.Err(`Unexpected end of pattern`)
     )
   }),
-
   _maybe_quantify : (fn(self : Self, a : RegexNode) -> Result(RegexNode, String))({
     pk := self._peek();
-    b := match(pk,
+    b := match(
+      pk,
       .Some(v) => v,
-      .None => { return .Ok(a); }
+      .None => {
+        return(.Ok(a));
+      }
     );
-
     cond(
       (b == u8(42)) => {
         self._pos = (self._pos + usize(1));
@@ -639,21 +659,21 @@ impl(RegexParser,
         .Ok(RegexNode.quantifier(a, usize(0), usize(1), greedy))
       },
       (b == u8(123)) => self._parse_counted_quantifier(a),
-      true => .Ok(a)
+      true =>.Ok(a)
     )
   }),
-
   _parse_quantified : (fn(self : Self) -> Result(RegexNode, String))({
     atom := self._parse_atom();
-    match(atom,
+    match(
+      atom,
       .Ok(a) => self._maybe_quantify(a),
-      .Err(e) => .Err(e)
+      .Err(e) =>.Err(e)
     )
   })
 );
-
 // Second impl block: helper methods first, then main parse loop
-impl(RegexParser,
+impl(
+  RegexParser,
   _make_sequence : (fn(self : Self, nodes : ArrayList(RegexNode)) -> RegexNode)(
     cond(
       (nodes.len() == usize(0)) => RegexNode.sequence(ArrayList(RegexNode).new()),
@@ -661,55 +681,55 @@ impl(RegexParser,
       true => RegexNode.sequence(nodes)
     )
   ),
-
   _finalize_frame : (fn(self : Self, alts : ArrayList(ArrayList(RegexNode)), seq : ArrayList(RegexNode)) -> RegexNode)({
     cond(
       (alts.len() == usize(0)) => {
-        return self._make_sequence(seq);
+        return(self._make_sequence(seq));
       },
       true => ()
     );
     alts.push(seq);
     result := self._make_sequence(alts.get(usize(0)).unwrap());
     i := usize(1);
-    while (i < alts.len()), (i = (i + usize(1))), {
+    while(i < alts.len(), i = (i + usize(1)), {
       right := self._make_sequence(alts.get(i).unwrap());
       result = RegexNode.alternation(result, right);
-    };
+    });
     result
   }),
-
   parse : (fn(self : Self) -> Result(RegexNode, String))({
     stack := ArrayList(ParseFrame).new();
     cur_alts := ArrayList(ArrayList(RegexNode)).new();
-    cur_seq  := ArrayList(RegexNode).new();
+    cur_seq := ArrayList(RegexNode).new();
     cur_non_cap := false;
     cur_group_idx := usize(0);
     cur_is_la := false;
     cur_is_lb := false;
     cur_is_pos := true;
-
-    while (!(self._at_end())), {
+    while(!(self._at_end()), {
       pk := self._peek();
-      b := match(pk,
+      b := match(
+        pk,
         .Some(v) => v,
-        .None => { break; }
+        .None => {
+          break;
+        }
       );
-
       cond(
         (b == u8(40)) => {
           // '(' — open group
           self._pos = (self._pos + usize(1));
-          stack.push(ParseFrame(
-            alternatives: cur_alts,
-            current: cur_seq,
-            is_non_capturing: cur_non_cap,
-            group_index: cur_group_idx,
-            is_lookahead: cur_is_la,
-            is_lookbehind: cur_is_lb,
-            is_positive: cur_is_pos
-          ));
-
+          stack.push(
+            ParseFrame(
+              alternatives : cur_alts,
+              current : cur_seq,
+              is_non_capturing : cur_non_cap,
+              group_index : cur_group_idx,
+              is_lookahead : cur_is_la,
+              is_lookbehind : cur_is_lb,
+              is_positive : cur_is_pos
+            )
+          );
           // Detect group type: (?:  (?<name>  (?=  (?!  (?<=  (?<!
           is_nc := false;
           g_idx := usize(0);
@@ -717,7 +737,8 @@ impl(RegexParser,
           is_lb := false;
           is_pos := true;
           pk2 := self._peek();
-          is_question := match(pk2,
+          is_question := match(
+            pk2,
             .Some(v) => (v == u8(63)),
             .None => false
           );
@@ -726,8 +747,9 @@ impl(RegexParser,
               has_next := ((self._pos + usize(1)) < self._bytes.len());
               cond(
                 has_next => {
-                  nb := self._bytes.get((self._pos + usize(1)));
-                  next_ch := match(nb,
+                  nb := self._bytes.get(self._pos + usize(1));
+                  next_ch := match(
+                    nb,
                     .Some(v) => v,
                     .None => u8(0)
                   );
@@ -756,7 +778,8 @@ impl(RegexParser,
                       // Check char after '<'
                       has_third := ((self._pos + usize(2)) < self._bytes.len());
                       third_ch := cond(
-                        has_third => match(self._bytes.get((self._pos + usize(2))),
+                        has_third => match(
+                          self._bytes.get(self._pos + usize(2)),
                           .Some(v) => v,
                           .None => u8(0)
                         ),
@@ -781,11 +804,14 @@ impl(RegexParser,
                         true => {
                           self._pos = (self._pos + usize(2));
                           name_bytes := ArrayList(u8).new();
-                          while (!(self._at_end())), {
+                          while(!(self._at_end()), {
                             name_b := self._peek();
-                            name_ch := match(name_b,
+                            name_ch := match(
+                              name_b,
                               .Some(v) => v,
-                              .None => { break; }
+                              .None => {
+                                break;
+                              }
                             );
                             cond(
                               (name_ch == u8(62)) => {
@@ -797,11 +823,11 @@ impl(RegexParser,
                                 self._pos = (self._pos + usize(1));
                               }
                             );
-                          };
+                          });
                           self._group_count = (self._group_count + usize(1));
                           g_idx = self._group_count;
                           group_name := String.from_bytes(name_bytes);
-                          self._group_names.push(GroupNameEntry(name: group_name, index: g_idx));
+                          self._group_names.push(GroupNameEntry(name : group_name, index : g_idx));
                         }
                       );
                     },
@@ -813,7 +839,6 @@ impl(RegexParser,
             },
             true => ()
           );
-
           cond(
             (((!(is_nc)) && (!(is_la))) && ((!(is_lb)) && (g_idx == usize(0)))) => {
               self._group_count = (self._group_count + usize(1));
@@ -821,7 +846,6 @@ impl(RegexParser,
             },
             true => ()
           );
-
           cur_alts = ArrayList(ArrayList(RegexNode)).new();
           cur_seq = ArrayList(RegexNode).new();
           cur_non_cap = is_nc;
@@ -835,25 +859,21 @@ impl(RegexParser,
           self._pos = (self._pos + usize(1));
           cond(
             (stack.len() == usize(0)) => {
-              return .Err(`Unexpected ')' without matching '('`);
+              return(.Err(`Unexpected ')' without matching '('`));
             },
             true => ()
           );
-
           inner := self._finalize_frame(cur_alts, cur_seq);
-
           // Save this group's type before restoring parent frame
           this_is_la := cur_is_la;
           this_is_lb := cur_is_lb;
-
           group_node := cond(
             cur_is_la => RegexNode.lookahead(inner, cur_is_pos),
             cur_is_lb => RegexNode.lookbehind(inner, cur_is_pos),
             cur_non_cap => RegexNode.non_capturing_group(inner),
             true => RegexNode.group(inner, cur_group_idx)
           );
-
-          parent := stack.get((stack.len() - usize(1))).unwrap();
+          parent := stack.get(stack.len() - usize(1)).unwrap();
           stack.pop();
           cur_alts = parent.alternatives;
           cur_seq = parent.current;
@@ -862,7 +882,6 @@ impl(RegexParser,
           cur_is_la = parent.is_lookahead;
           cur_is_lb = parent.is_lookbehind;
           cur_is_pos = parent.is_positive;
-
           // Lookahead/lookbehind should not be quantified
           cond(
             (this_is_la || this_is_lb) => {
@@ -870,9 +889,14 @@ impl(RegexParser,
             },
             true => {
               quantified := self._maybe_quantify(group_node);
-              match(quantified,
-                .Ok(q) => { cur_seq.push(q); },
-                .Err(e) => { return .Err(e); }
+              match(
+                quantified,
+                .Ok(q) => {
+                  cur_seq.push(q);
+                },
+                .Err(e) => {
+                  return(.Err(e));
+                }
               );
             }
           );
@@ -885,26 +909,26 @@ impl(RegexParser,
         },
         true => {
           atom := self._parse_quantified();
-          match(atom,
-            .Ok(a) => { cur_seq.push(a); },
-            .Err(e) => { return .Err(e); }
+          match(
+            atom,
+            .Ok(a) => {
+              cur_seq.push(a);
+            },
+            .Err(e) => {
+              return(.Err(e));
+            }
           );
         }
       );
-    };
-
+    });
     cond(
       (stack.len() > usize(0)) => {
-        return .Err(`Unterminated group — expected ')'`);
+        return(.Err(`Unterminated group — expected ')'`));
       },
       true => ()
     );
-
     result := self._finalize_frame(cur_alts, cur_seq);
     .Ok(result)
   })
 );
-
-export
-  RegexParser
-;
+export(RegexParser);