Regex

regex.match(pattern, s) returns the first match as an object with fields match (the matched substring), groups (capture groups in order), start, and end (byte offsets). On no match it returns null, so handler code branches with (m is not null) before reading fields.

<p> [regex.match('\\d+', 'abc 123 xyz')]

regex.find_all(pattern, s) returns every non-overlapping match in an array. Each element has the same shape as the single-match form.

<p> [regex.find_all('\\d+', '1 two 3 four 55')]

regex.replace(pattern, s, replacement) swaps every match. The replacement string can reference capture groups with $1, $2, etc. For a literal dollar sign in the output, double it ($$).

<p> [regex.replace('(\\w+)=(\\d+)', 'a=1, b=2', '$2 of $1')]

regex.split(pattern, s) cuts the string wherever the pattern matches. Common case: collapsing arbitrary whitespace runs into a clean array of tokens.

<p> [regex.split('\\s+', 'one  two three')]

Each match object exposes its capture groups in an array, in source order. Use the array to pull out the parts of the match without re-parsing the matched substring.

> page
hits: regex.find_all('(\\w+)=(\\d+)', 'a=1, b=2, c=33')

<ul>
    [h] in hits
        <li> [h.groups[0]] → [h.groups[1]]

The RE2 dialect rules out a few features common in PCRE: no backreferences in patterns (\\1), no lookahead / lookbehind. The trade-off is guaranteed linear-time evaluation, so pasted patterns can never catastrophically backtrack. Backrefs in replacements ($1) are fine; the restriction is only on patterns.