@shd101wyy/yo 0.1.26 → 0.1.28

package/std/regex/match.yo

@@ -1,81 +1,70 @@
 //! Match result type — represents the result of a regex match,
 //! including the matched text, position, and captured groups.
-
-open import "std/collections/array_list";
-open import "std/string";
-{ GroupNameEntry } :: import "./node.yo";
-
+open(import("std/collections/array_list"));
+open(import("std/string"));
+{ GroupNameEntry } :: import("./node.yo");
 /// A single regex match result.
 RegexMatch :: object(
-  _value       : String,
-  _index       : usize,
-  _input       : String,
-  _groups      : ArrayList(Option(String)),
+  _value : String,
+  _index : usize,
+  _input : String,
+  _groups : ArrayList(Option(String)),
   _group_names : ArrayList(GroupNameEntry)
 );
-
-impl(RegexMatch,
+impl(
+  RegexMatch,
   // Create a match result
   new : (fn(value : String, index : usize, input : String, groups : ArrayList(Option(String)), group_names : ArrayList(GroupNameEntry)) -> Self)(
     Self(
-      _value: value,
-      _index: index,
-      _input: input,
-      _groups: groups,
-      _group_names: group_names
+      _value : value,
+      _index : index,
+      _input : input,
+      _groups : groups,
+      _group_names : group_names
     )
   ),
-
   // Get the full matched text
   value : (fn(self : Self) -> String)(
     self._value
   ),
-
   // Get the start position (character index) of the match
   index : (fn(self : Self) -> usize)(
     self._index
   ),
-
   // Get the original input string
   input : (fn(self : Self) -> String)(
     self._input
   ),
-
   // Get capture group by index (1-based, group 0 is the full match)
   group : (fn(self : Self, idx : usize) -> Option(String))(
     cond(
-      (idx == usize(0)) => .Some(self._value),
+      (idx == usize(0)) =>.Some(self._value),
       true => {
         actual_idx := (idx - usize(1));
         cond(
           (actual_idx < self._groups.len()) => self._groups.get(actual_idx).unwrap(),
-          true => .None
+          true =>.None
         )
       }
     )
   ),
-
   // Get capture group by name
   named_group : (fn(self : Self, name : String) -> Option(String))({
     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 self.group(entry.index);
+          return(self.group(entry.index));
         },
         true => ()
       );
-    };
+    });
     .None
   }),
-
   // Get number of capture groups (not counting group 0)
   group_count : (fn(self : Self) -> usize)(
     self._groups.len()
   )
 );
-
-export
-  RegexMatch
-;
+export(RegexMatch);

package/std/regex/node.yo

@@ -3,16 +3,13 @@
 //! The parser produces a tree of `RegexNode` objects representing the
 //! structure of a regex pattern. Nodes are reference-counted objects
 //! since they form a recursive tree.
-
-open import "std/collections/array_list";
-open import "std/string";
-
+open(import("std/collections/array_list"));
+open(import("std/string"));
 /// A range of characters for character classes, e.g. `a`–`z`.
 CharRange :: struct(
-  low  : u32,
+  low : u32,
   high : u32
 );
-
 // Anchor types for ^ $ \b \B
 AnchorKind :: enum(
   Start,
@@ -20,7 +17,6 @@ AnchorKind :: enum(
   WordBoundary,
   NonWordBoundary
 );
-
 // Node kind tag
 NodeKind :: enum(
   Literal,
@@ -36,248 +32,234 @@ NodeKind :: enum(
   Lookahead,
   Lookbehind
 );
-
 // Entry mapping a named group to its index
 GroupNameEntry :: struct(
-  name  : String,
+  name : String,
   index : usize
 );
-
 // The regex AST node type.
 // Uses `object(...)` for reference counting since nodes are recursive.
 // Self-reference via `Self` (like LinkedList's Node).
 RegexNode :: object(
-  kind     : NodeKind,
+  kind : NodeKind,
   children : ArrayList(Self),
   // For Literal nodes: the codepoint
   codepoint : u32,
   // For CharClass nodes: ranges and negation flag
-  ranges   : ArrayList(CharRange),
-  negated  : bool,
+  ranges : ArrayList(CharRange),
+  negated : bool,
   // For Quantifier nodes: min, max, greedy
-  q_min    : usize,
-  q_max    : usize,
+  q_min : usize,
+  q_max : usize,
   q_greedy : bool,
   // For Group/Save nodes: group index
   group_index : usize,
   // For Anchor nodes
-  anchor   : AnchorKind
+  anchor : AnchorKind
 );
-
-impl(RegexNode,
+impl(
+  RegexNode,
   // Create a literal node matching a single codepoint
   literal : (fn(cp : u32) -> Self)(
     Self(
-      kind: .Literal,
-      children: ArrayList(RegexNode).new(),
-      codepoint: cp,
-      ranges: ArrayList(CharRange).new(),
-      negated: false,
-      q_min: usize(0),
-      q_max: usize(0),
-      q_greedy: true,
-      group_index: usize(0),
-      anchor: .Start
+      kind :.Literal,
+      children : ArrayList(RegexNode).new(),
+      codepoint : cp,
+      ranges : ArrayList(CharRange).new(),
+      negated : false,
+      q_min : usize(0),
+      q_max : usize(0),
+      q_greedy : true,
+      group_index : usize(0),
+      anchor :.Start
     )
   ),
-
   // Create a dot (any char) node
   dot : (fn() -> Self)(
     Self(
-      kind: .Dot,
-      children: ArrayList(RegexNode).new(),
-      codepoint: u32(0),
-      ranges: ArrayList(CharRange).new(),
-      negated: false,
-      q_min: usize(0),
-      q_max: usize(0),
-      q_greedy: true,
-      group_index: usize(0),
-      anchor: .Start
+      kind :.Dot,
+      children : ArrayList(RegexNode).new(),
+      codepoint : u32(0),
+      ranges : ArrayList(CharRange).new(),
+      negated : false,
+      q_min : usize(0),
+      q_max : usize(0),
+      q_greedy : true,
+      group_index : usize(0),
+      anchor :.Start
     )
   ),
-
   // Create a character class node
   char_class : (fn(ranges : ArrayList(CharRange), negated : bool) -> Self)(
     Self(
-      kind: .CharClass,
-      children: ArrayList(RegexNode).new(),
-      codepoint: u32(0),
-      ranges: ranges,
-      negated: negated,
-      q_min: usize(0),
-      q_max: usize(0),
-      q_greedy: true,
-      group_index: usize(0),
-      anchor: .Start
+      kind :.CharClass,
+      children : ArrayList(RegexNode).new(),
+      codepoint : u32(0),
+      ranges : ranges,
+      negated : negated,
+      q_min : usize(0),
+      q_max : usize(0),
+      q_greedy : true,
+      group_index : usize(0),
+      anchor :.Start
     )
   ),
-
   // Create an anchor node (^, $, \b, \B)
   anchor_node : (fn(kind : AnchorKind) -> Self)(
     Self(
-      kind: .Anchor,
-      children: ArrayList(RegexNode).new(),
-      codepoint: u32(0),
-      ranges: ArrayList(CharRange).new(),
-      negated: false,
-      q_min: usize(0),
-      q_max: usize(0),
-      q_greedy: true,
-      group_index: usize(0),
-      anchor: kind
+      kind :.Anchor,
+      children : ArrayList(RegexNode).new(),
+      codepoint : u32(0),
+      ranges : ArrayList(CharRange).new(),
+      negated : false,
+      q_min : usize(0),
+      q_max : usize(0),
+      q_greedy : true,
+      group_index : usize(0),
+      anchor : kind
     )
   ),
-
   // Create a sequence node (concatenation of children)
   sequence : (fn(nodes : ArrayList(RegexNode)) -> Self)(
     Self(
-      kind: .Sequence,
-      children: nodes,
-      codepoint: u32(0),
-      ranges: ArrayList(CharRange).new(),
-      negated: false,
-      q_min: usize(0),
-      q_max: usize(0),
-      q_greedy: true,
-      group_index: usize(0),
-      anchor: .Start
+      kind :.Sequence,
+      children : nodes,
+      codepoint : u32(0),
+      ranges : ArrayList(CharRange).new(),
+      negated : false,
+      q_min : usize(0),
+      q_max : usize(0),
+      q_greedy : true,
+      group_index : usize(0),
+      anchor :.Start
     )
   ),
-
   // Create an alternation node (left | right)
   alternation : (fn(left : RegexNode, right : RegexNode) -> Self)({
     kids := ArrayList(RegexNode).new();
     kids.push(left);
     kids.push(right);
     Self(
-      kind: .Alternation,
-      children: kids,
-      codepoint: u32(0),
-      ranges: ArrayList(CharRange).new(),
-      negated: false,
-      q_min: usize(0),
-      q_max: usize(0),
-      q_greedy: true,
-      group_index: usize(0),
-      anchor: .Start
+      kind :.Alternation,
+      children : kids,
+      codepoint : u32(0),
+      ranges : ArrayList(CharRange).new(),
+      negated : false,
+      q_min : usize(0),
+      q_max : usize(0),
+      q_greedy : true,
+      group_index : usize(0),
+      anchor :.Start
     )
   }),
-
   // Create a quantifier node (wrapping a child)
   // max_val of 0 means unbounded (infinity)
   quantifier : (fn(child : RegexNode, min_val : usize, max_val : usize, greedy : bool) -> Self)({
     kids := ArrayList(RegexNode).new();
     kids.push(child);
     Self(
-      kind: .Quantifier,
-      children: kids,
-      codepoint: u32(0),
-      ranges: ArrayList(CharRange).new(),
-      negated: false,
-      q_min: min_val,
-      q_max: max_val,
-      q_greedy: greedy,
-      group_index: usize(0),
-      anchor: .Start
+      kind :.Quantifier,
+      children : kids,
+      codepoint : u32(0),
+      ranges : ArrayList(CharRange).new(),
+      negated : false,
+      q_min : min_val,
+      q_max : max_val,
+      q_greedy : greedy,
+      group_index : usize(0),
+      anchor :.Start
     )
   }),
-
   // Create a capturing group node
   group : (fn(child : RegexNode, index : usize) -> Self)({
     kids := ArrayList(RegexNode).new();
     kids.push(child);
     Self(
-      kind: .Group,
-      children: kids,
-      codepoint: u32(0),
-      ranges: ArrayList(CharRange).new(),
-      negated: false,
-      q_min: usize(0),
-      q_max: usize(0),
-      q_greedy: true,
-      group_index: index,
-      anchor: .Start
+      kind :.Group,
+      children : kids,
+      codepoint : u32(0),
+      ranges : ArrayList(CharRange).new(),
+      negated : false,
+      q_min : usize(0),
+      q_max : usize(0),
+      q_greedy : true,
+      group_index : index,
+      anchor :.Start
     )
   }),
-
   // Create a non-capturing group node
   non_capturing_group : (fn(child : RegexNode) -> Self)({
     kids := ArrayList(RegexNode).new();
     kids.push(child);
     Self(
-      kind: .NonCapturingGroup,
-      children: kids,
-      codepoint: u32(0),
-      ranges: ArrayList(CharRange).new(),
-      negated: false,
-      q_min: usize(0),
-      q_max: usize(0),
-      q_greedy: true,
-      group_index: usize(0),
-      anchor: .Start
+      kind :.NonCapturingGroup,
+      children : kids,
+      codepoint : u32(0),
+      ranges : ArrayList(CharRange).new(),
+      negated : false,
+      q_min : usize(0),
+      q_max : usize(0),
+      q_greedy : true,
+      group_index : usize(0),
+      anchor :.Start
     )
   }),
-
   // Create a backreference node (\1, \k<name>)
   backreference : (fn(group_idx : usize) -> Self)(
     Self(
-      kind: .Backreference,
-      children: ArrayList(RegexNode).new(),
-      codepoint: u32(0),
-      ranges: ArrayList(CharRange).new(),
-      negated: false,
-      q_min: usize(0),
-      q_max: usize(0),
-      q_greedy: true,
-      group_index: group_idx,
-      anchor: .Start
+      kind :.Backreference,
+      children : ArrayList(RegexNode).new(),
+      codepoint : u32(0),
+      ranges : ArrayList(CharRange).new(),
+      negated : false,
+      q_min : usize(0),
+      q_max : usize(0),
+      q_greedy : true,
+      group_index : group_idx,
+      anchor :.Start
     )
   ),
-
   // Create a lookahead node (?=...) or (?!...)
   // negated=false means positive, negated=true means negative
   lookahead : (fn(child : RegexNode, positive : bool) -> Self)({
     kids := ArrayList(RegexNode).new();
     kids.push(child);
     Self(
-      kind: .Lookahead,
-      children: kids,
-      codepoint: u32(0),
-      ranges: ArrayList(CharRange).new(),
-      negated: (!(positive)),
-      q_min: usize(0),
-      q_max: usize(0),
-      q_greedy: true,
-      group_index: usize(0),
-      anchor: .Start
+      kind :.Lookahead,
+      children : kids,
+      codepoint : u32(0),
+      ranges : ArrayList(CharRange).new(),
+      negated : (!(positive)),
+      q_min : usize(0),
+      q_max : usize(0),
+      q_greedy : true,
+      group_index : usize(0),
+      anchor :.Start
     )
   }),
-
   // Create a lookbehind node (?<=...) or (?<!...)
   // negated=false means positive, negated=true means negative
   lookbehind : (fn(child : RegexNode, positive : bool) -> Self)({
     kids := ArrayList(RegexNode).new();
     kids.push(child);
     Self(
-      kind: .Lookbehind,
-      children: kids,
-      codepoint: u32(0),
-      ranges: ArrayList(CharRange).new(),
-      negated: (!(positive)),
-      q_min: usize(0),
-      q_max: usize(0),
-      q_greedy: true,
-      group_index: usize(0),
-      anchor: .Start
+      kind :.Lookbehind,
+      children : kids,
+      codepoint : u32(0),
+      ranges : ArrayList(CharRange).new(),
+      negated : (!(positive)),
+      q_min : usize(0),
+      q_max : usize(0),
+      q_greedy : true,
+      group_index : usize(0),
+      anchor :.Start
     )
   })
 );
-
-export
+export(
   RegexNode,
   NodeKind,
   CharRange,
   AnchorKind,
   GroupNameEntry
-;
+);