Regex¶

1

import "std/text/regex";

Match struct¶

A single match of a Regex against an input string: the whole-match text and bounds, plus one entry per capturing group in groups (in group-number order, i.e. groups[0] is group 1) - an empty Optional means that group did not participate in the match (e.g. it was on the untaken side of an alternation).

Fields¶

Regex struct¶

A compiled regex pattern. Construct one with compileRegex.

Supported syntax: literals, ., character classes ([abc], [^abc], [a-z]), the shorthand classes \d \D \w \W \s \S, anchors ^ $, the quantifiers * + ? {n} {n,} {n,m} (greedy only), alternation |, and groups (...) / (?:...). Lazy quantifiers, backreferences, lookaround and multiline mode are not supported.

Matching runs on a Thompson-construction virtual machine (see "std/text/regex/regex-matcher"), not backtracking, so no pattern can trigger catastrophic-backtracking blowup: matching a pattern of m compiled instructions against an input of length n is always O(n * m).

Methods¶

isMatch¶

1

public f<bool> Regex.isMatch(const String& input)

Check whether the pattern matches anywhere in the input string

Parameters

Returns: bool — Whether the pattern matches anywhere in input

find¶

1

public f<Optional<Match>> Regex.find(const String& input, unsigned long startIndex = 0l)

Find the first match at or after startIndex

Parameters

Returns: Optional<Match> — The first match at or after startIndex, or an empty Optional if there is none

findAll¶

1

public f<Vector<Match>> Regex.findAll(const String& input)

Find every non-overlapping match in the input string, left to right

Parameters

Returns: Vector<Match> — Every non-overlapping match, in order

replace¶

1

public f<String> Regex.replace(const String& input, const String& replacement)

Replace the first match with replacement. replacement may reference capture groups with $0 (the whole match) through $9; $$ inserts a literal $.

Parameters

Returns: String — input with its first match, if any, replaced

replaceAll¶

1

public f<String> Regex.replaceAll(const String& input, const String& replacement)

Replace every non-overlapping match with replacement. replacement may reference capture groups with $0 (the whole match) through $9; $$ inserts a literal $.

Parameters

Returns: String — input with every non-overlapping match replaced

split¶

1

public f<Vector<String>> Regex.split(const String& input)

Split the input string at every non-overlapping, non-empty match

Parameters

Returns: Vector<String> — The pieces of input between matches, including a leading/trailing empty piece where input starts/ends with a match

Functions¶

compileRegex¶

1

public f<Result<Regex>> compileRegex(const String& pattern)

Compile a regex pattern.

Parameters

Returns: Result<Regex> — The compiled regex, or an error describing the first problem encountered in the pattern