Regex

Alternation. Always size ≥ 2. parts is an AltBranches, not a plain Set like Inter: it still needs Set-like equality/hashing for ACI normalization (two Alts built from the same branches must be == and hash identically regardless of order, or Subset.isEmpty's visited-state dedup - and the finite-derivative-state-space guarantee it relies on - would silently stop collapsing equivalent states) - see AltBranches's own equals/hashCode. But iteration order matters too, unlike Inter: it's a pattern's only record of alternation branch priority (a|b prefers a), which every no-backtracking submatch algorithm needs for leftmost-first disambiguation (see Capture.scala) and which nothing before that ever needed to preserve. Regex.alt/| build it in exactly the order they're given (deduplicated, first occurrence kept) rather than normalizing it away.

(A Scala 3 enum case can't carry its own equals/hashCode override directly - only plain classes can - hence AltBranches being a separate wrapper type instead of Alt's stored field simply being an order-preserving Vector[Regex] with the override inline.)

Matches any single code point in set.

Complement ¬r.

Concatenation a · b.

Matches no string.

Matches the empty string ε.

Capturing group (...) / named group (?...). Purely a marker for where a capture begins and ends - L(Group(_, _, inner)) = L(inner) exactly, and every operation in this file (nullable, alphabetBoundaries, hasStartAnchor, and every smart constructor) treats it as fully transparent, recursing straight through to inner. Subset goes one step further and erases every Group node outright before ever deriving through it (see that file's doc comment for why) - so this node only matters to code that walks a Regex tree directly looking for where groups are, not to anything answering a containment/matching question through Subset.

index is the group's 1-based number, assigned left-to-right by opening paren (0 is reserved for "the whole match", which isn't its own node); name is Some for (?...), None for a bare (...). (?:...) (explicitly non-capturing) produces no Group node at all, same as today.

Intersection. Stored as a Set for ACI normalization. Always size ≥ 2.

Zero-width lookahead assertion. positive = true is (?=r): holds at a position iff some prefix of the string remaining there is in L(r), without consuming any of it. positive = false is (?!r): holds iff no such prefix exists.

Bounded repetition r{lo,hi} (hi may be Int.MaxValue for the unbounded {lo,} form). Kept as a single node carrying lo/hi symbolically, instead of unfolding into that many copies of r - see Regex.repeat for why, and Subset.rawDerive for how a Brzozowski derivative is taken through it without ever materializing the unfolded form.

Kleene star r*.

^/\A (start-of-input anchor). Unlike Look, this can't be resolved by re-deriving a sub-pattern alongside whatever follows it - it's satisfied only in the state before any character has been consumed by anything, anywhere in the whole match, not just locally at this node. See Subset.derive's unconditional post-pass, which is what actually enforces that. $/\Z/\z don't need an equivalent node - under this library's whole-string matches() semantics they're all exactly (?!.) (negative lookahead of any code point), expressed directly with Look at parse time.