/regex rosetta stone/i

Rust

regex crate
About
Automaton, no backtracking: match time is linear in the input, and constructs that need backtracking do not exist.
Verified on
regex crate 1.13.2
Offsets are counted in bytes.
Found in
regex crate, ripgrep
its own documentation
Flags
R crlfU ungreedyi ignore casem multilines dotallx verbose
Character classes 11 of 26
SyntaxMatchesNotesTry
. Any characterAny single character. Whether that includes a newline depends on the dialect and its flags.

Does not match a newline.

test
[abc]not[^abc] One of a set of characters test
[a-z] One of a range of characters test
[\]] Backslash escape inside a setInside a bracket expression a backslash takes the special meaning from the next character. Where this is missing, a backslash there is a member like any other. test
[\d] Class escape inside a setA class escape such as the one for a digit, used as a member of a bracket expression. test
[\D] Negated class escape inside a setA negated class escape, such as the one for anything but a digit, used as a member of a bracket expression. test
\d[[:digit:]]not\D Digit

Matches the decimal digits of every script, not only 0 to 9.

test
\w[[:alnum:]_]not\W Word characterA letter, a digit or an underscore.

Unicode-aware: matches letters and digits of every script.

test
\s[[:space:]]not\S Whitespace

Also matches the no-break space.

test
n/a Horizontal whitespaceA space or a tab, but not a line break. not in Rust

Tried: \h does not compile.

who has it
n/a Vertical whitespaceA line break character of any kind. not in Rust

Tried: \v compiles, and matches as plain text or not at all.

who has it
n/a Any character except newlineNever matches a newline, whatever the flags. not in Rust

Tried: \N does not compile.

who has it
n/a Any line break sequenceOne line break, with CR LF taken as a single unit. not in Rust

Tried: \R does not compile.

who has it
n/a Alphabetic character (shorthand) not in Rust

Tried: \a compiles, and matches as plain text or not at all.

who has it
n/a Lowercase letter (shorthand) not in Rust

Tried: \l does not compile.

who has it
n/a Uppercase letter (shorthand) not in Rust

Tried: \u does not compile.

who has it
n/a Hexadecimal digit (shorthand) not in Rust

Tried: \h does not compile.

who has it
[X&&Y] Class intersectionCharacters that are in both classes. test
[X--Y][X&&[^Y]] Class subtractionCharacters in the first class that are not in the second. test
n/a Head-of-word character (shorthand)A letter or the underscore: what a word may start with. not in Rust

Tried: \h does not compile.

who has it
n/a Octal digit (shorthand) not in Rust

Tried: \o does not compile.

who has it
n/a Identifier characterA character allowed in an identifier. In Vim the set comes from the 'isident' option. not in Rust

Tried: \i does not compile.

who has it
n/a Keyword characterA character allowed in a keyword. In Vim the set comes from the 'iskeyword' option. not in Rust

Tried: \k does not compile.

who has it
n/a File name characterA character allowed in a file name. In Vim the set comes from the 'isfname' option. not in Rust

Tried: \f compiles, and matches as plain text or not at all.

who has it
n/a Printable characterA character that is displayed as itself. In Vim the set comes from the 'isprint' option. not in Rust

Tried: \p does not compile.

who has it
n/a Any single byteOne code unit, even where that is part of a longer character, and even a newline. not in Rust

Tried: \C does not compile.

who has it
Anchors 8 of 14
SyntaxMatchesNotesTry
^ Start of the text or lineStart of the text. With a multiline flag, or always in some dialects, also the start of each line. test
$ End of the text or line

Matches only at the very end, not before a final newline.

test
\A Start of the textStart of the text only, whatever the flags. test
\z End of the textThe very end of the text, whatever the flags. test
n/a End of the text, or before a final newline not in Rust

Tried: a\Z does not compile.

who has it
\b Word boundaryThe position between a word character and a non-word character or an end of the text.

Unicode-aware: a letter outside ASCII is a word character.

test
\B Not a word boundary test
\< Start of a word test
\> End of a word test
n/a Where the previous match endedThe position where the last match stopped, or the start of the text for the first match. not in Rust

Tried: \Ga does not compile.

who has it
n/a Reset the start of the matchEverything matched so far is required but left out of the reported match. not in Rust

Tried: foo\Kbar does not compile.

who has it
n/a Start of symbolBefore a run of word and symbol characters, such as an identifier with an underscore in it. not in Rust

Tried: \_<b compiles, and matches as plain text or not at all.

who has it
n/a End of symbol not in Rust

Tried: a\_> compiles, and matches as plain text or not at all.

who has it
n/a Cursor positionWhere the editor's cursor is in the buffer being searched. not in Rust

doc Not run on an engine: taken from the documentation.

who has it
Quantifiers 8 of 9
SyntaxMatchesNotesTry
X? Zero or one test
X* Zero or more test
X+ One or more test
X{N} Exactly N times test
X{N,} N or more times test
X{0,M} At most M times test
X{N,M} Between N and M times test
X*?X+?X?? Lazy quantifierRepeat as few times as possible instead of as many as possible. test
n/a Possessive quantifierRepeat as many times as possible and never give any of it back. not in Rust

Tried: a*+a compiles, and means something else.

who has it
Groups and alternation 4 of 16
SyntaxMatchesNotesTry
(X) Capture group test
(?:X) Non-capturing group test
(?<NAME>X)(?P<NAME>X) Named capture group test
X|Y Alternation

Takes the first alternative that matches, even when a later one is longer.

test
n/a Backreference by numberThe same text that capture group N matched. not in Rust

Tried: (a)\1 does not compile.

who has it
n/a Backreference by name not in Rust

Tried: (?<n>a)\k<n> does not compile.

who has it
n/a Backreference by relative positionThe group N groups back from here. not in Rust

Tried: (a)\g-1 does not compile.

who has it
n/a Atomic groupOnce the group has matched, the engine never tries a different way to match it. not in Rust

Tried: (?>a+)b does not compile.

who has it
n/a Branch reset groupEvery alternative numbers its capture groups from the same start. not in Rust

Tried: (?|(a)|(b)) does not compile.

who has it
n/a ConditionalMatch one pattern if a capture group took part, otherwise another. not in Rust

Tried: (<)?a(?(1)>|!) does not compile.

who has it
n/a Recurse into the whole pattern not in Rust

Tried: \((?:a|(?R))\) compiles, and means something else.

who has it
n/a Call a group as a subroutineMatch the pattern of capture group N again at this point, not the text it matched. not in Rust

Tried: (a|b)(?1) does not compile.

who has it
n/a Comment not in Rust

Tried: a(?#note)b does not compile.

who has it
n/a Explicitly numbered groupA capture group that is given its number, whatever its position. not in Rust

Tried: (?<2>a) does not compile.

who has it
n/a Call an earlier group by relative positionMatch the pattern of the Nth group before this point again. not in Rust

Tried: (a|b)(?-1) does not compile.

who has it
n/a Call a later group by relative positionMatch the pattern of the Nth group after this point here as well. not in Rust

Tried: (?+1)(a|b) does not compile.

who has it
Lookaround 0 of 4
SyntaxMatchesNotesTry
n/a LookaheadWhat follows must match X, but is not part of the match. not in Rust

Tried: a(?=c) does not compile.

who has it
n/a Negative lookahead not in Rust

Tried: a(?!b) does not compile.

who has it
n/a LookbehindWhat comes before must match X, but is not part of the match. not in Rust

Tried: (?<=c)a does not compile.

who has it
n/a Negative lookbehind not in Rust

Tried: (?<!b)a does not compile.

who has it
Escape sequences 10 of 16
SyntaxMatchesNotesTry
\. Escape a special characterTake the next character literally. test
n/a Quote a run of textTake everything between the markers literally. not in Rust

Tried: \Qa.b\E does not compile.

who has it
\t Tab test
\n Newline test
\r Carriage return test
\f Form feed test
\v Vertical tab test
\a Alert (bell) test
n/a Backspace not in Rust

Tried: [\b] does not compile.

who has it
n/a Escape character not in Rust

Tried: \e does not compile.

who has it
n/a Control characterThe control character typed as Ctrl plus the letter. not in Rust

Tried: \cA does not compile.

who has it
n/a Character by octal code not in Rust

Tried: \101 does not compile.

who has it
\xHH Character by two-digit hex code test
\uHHHH\UHHHHHHHH\x{HHHH}\u{HHHH} Character by Unicode code point test
n/a Character by Unicode name not in Rust

Tried: \N{DIGIT ONE} does not compile.

who has it
\x00\u0000\x{0} NUL characterThe character with code 0.

\0 is an octal escape and is rejected unless RegexBuilder::octal(true) is set; with it, up to three octal digits are read. Rust strings can contain U+0000, so the haystack can too.

doc Not run on an engine: taken from the documentation.

Flags and modes 11 of 14
SyntaxMatchesNotesTry
flag i(?i) Ignore case test
flag m(?m) MultilineThe line anchors also match at the start and end of every line. test
flag s(?s) Dot matches newline test
flag x(?x) Free spacingWhitespace in the pattern is ignored, and a # starts a comment. test
flag U(?U) Swap greedy and lazy test
(?FLAGS) Turn a mode on inside the patternApplies from this point to the end of the pattern or the enclosing group. test
(?FLAGS) Turn a mode on in the middle of the patternThe mode applies from where the flag stands, not to what comes before it. Some dialects accept an inline flag only at the very start of the pattern. test
(?FLAGS:X) Turn a mode on for one group test
(?-FLAGS) Turn a mode off inside the pattern test
(?-u) ASCII-only classesMakes the shorthand classes such as the digit class match ASCII characters only. partial

Turns Unicode off for everything after it, not for the classes alone: \p{...} and a character beyond ASCII are then errors.

test
(?u) Unicode classesMakes the shorthand classes such as the digit class match by Unicode property.

On by default, so (?u) only matters after (?-u).

\d matches Unicode digits with no mode set.

test
n/a No automatic capturePlain parentheses group without capturing; only named groups capture. not in Rust

Tried: (?n)(a)(?<x>b) does not compile.

who has it
n/a Locale-dependent classesClasses and case folding follow the current locale. not in Rust

The flags are i, m, s, R, U, u and x only. The u flag switches between Unicode and ASCII rules, never a locale.

doc Not run on an engine: taken from the documentation.

who has it
n/a Native character set rulesPerl's rules from before 5.14: the pattern and the text decide between native and Unicode rules. not in Rust

doc Not run on an engine: taken from the documentation.

who has it
POSIX named classes 1 of 1
SyntaxMatchesNotesTry
[[:NAME:]]not[^[:NAME:]] POSIX named classA named set of characters, written inside a bracket expression.

14 names: alnum alpha ascii blank cntrl digit graph lower print punct space upper word xdigit

Not here: nonascii multibyte

test
POSIX collating symbols 0 of 2
SyntaxMatchesNotesTry
n/a Equivalence classEvery character that collates the same as X in the current locale. not in Rust

Tried: [[=a=]] compiles, and means something else.

who has it
n/a Collating symbol by nameA single collating element, written by its POSIX name inside a bracket expression. not in Rust

Tried: [[.SOH.]] compiles, and means something else.

who has it
Unicode properties 2 of 4
SyntaxMatchesNotesTry
\p{NAME}not\P{NAME} Unicode general category

36 names: L Ll Lm Lo Lt Lu C Cc Cf Cn Co M Mc Me Mn N Nd Nl No P Pc Pd Pe Pi Pf Po Ps S Sc Sk Sm So Z Zl Zp Zs

test
\p{NAME}not\P{NAME} Unicode script

8 names: Latin Greek Cyrillic Hebrew Arabic Han Hiragana Thai

test
n/a Extended grapheme clusterOne character as a reader sees it: a base character with its combining marks. not in Rust

Tried: \X does not compile.

who has it
n/a Unicode text boundaryA boundary as Unicode's segmentation rules define it, which is not the same as a boundary between word and non-word characters. not in Rust

Tried: e\b{gcb} does not compile.

who has it
Syntax table classes 0 of 2
SyntaxMatchesNotesTry
n/a Syntax classA character with the given role in the syntax table: whitespace, word, symbol, punctuation, a bracket. not in Rust

Tried: \s- compiles, and matches as plain text or not at all.

who has it
n/a Character categoryA character in one of the editor's character categories, most of which are scripts. not in Rust

Tried: \ca does not compile.

who has it
Host language 9 of 15
SyntaxMatchesNotesTry
r"PATTERN"r#"PATTERN"#"PATTERN" Pattern in source codeHow a pattern is written where it is used: a regex literal with its delimiters, or the kind of string the documentation recommends.

No regex literal; the crate documentation uses raw strings. r"..." cannot contain a double quote, r#"..."# can; in a normal "..." string every backslash is doubled.

doc Not run on an engine: taken from the documentation.

RegexBuilder::new(PATTERN).case_insensitive(true).build() Flags outside the patternWhere flags such as case-insensitive go when they are not written inside the pattern.

There is no FLAGS value: each flag is a builder method (case_insensitive, multi_line, dot_matches_new_line, crlf, swap_greed, ignore_whitespace, unicode). build() returns a Result.

doc Not run on an engine: taken from the documentation.

Regex::new(PATTERN)regex!(PATTERN)LazyLock::new(|| Regex::new(PATTERN).unwrap()) Compile once and reuseBuild a pattern object and keep it.

Regex::new returns a Result. regex! takes a string literal, keeps the Regex in a static, and panics on first use if the pattern is invalid.

doc Not run on an engine: taken from the documentation.

Regex::new(PATTERN).unwrap().is_match(TEXT)Regex::new(PATTERN).unwrap().find(TEXT)Regex::new(PATTERN).unwrap().captures(TEXT) Search a textTest whether the pattern matches anywhere in a text, or get the first match.

Not anchored: all three search anywhere in TEXT. find returns Option<Match> and captures returns Option<Captures> for the first match.

doc Not run on an engine: taken from the documentation.

Regex::new(PATTERN).unwrap().find_iter(TEXT)Regex::new(PATTERN).unwrap().captures_iter(TEXT) Every matchGet all the matches that do not overlap.

Both return an iterator over successive non-overlapping matches; captures_iter also gives the groups.

doc Not run on an engine: taken from the documentation.

Regex::new(PATTERN).unwrap().replace(TEXT, REPLACEMENT)Regex::new(PATTERN).unwrap().replace_all(TEXT, REPLACEMENT)Regex::new(PATTERN).unwrap().replacen(TEXT, limit, REPLACEMENT) Replace matches

replace replaces the first match only. replace_all replaces every match and replacen at most limit of them, where a limit of 0 means all.

doc Not run on an engine: taken from the documentation.

&caps[NUM]&caps["NAME"]caps.get(NUM)caps.name("NAME") Captured group, in codeRead what a group captured after a match.

caps is the Captures returned by captures(TEXT); group 0 is the whole match. Indexing panics when the group did not match, while get and name return Option<Match>.

doc Not run on an engine: taken from the documentation.

$NUM${NUM}$NAME${NAME} Captured group, in replacement text

The unbraced reference takes the longest possible name, so $1a is the group named 1a. Write ${1}0 to follow group 1 with a digit.

doc Not run on an engine: taken from the documentation.

$0${0} Whole match, in replacement text

A literal $ is written $$. Wrapping the replacement in NoExpand turns expansion off.

doc Not run on an engine: taken from the documentation.

n/a Match once until resetA match operator that succeeds one time only, until it is reset. not in Rust

doc Not run on an engine: taken from the documentation.

who has it
n/a Keep the position after a failed matchIn a repeated search, a failed match does not send the next one back to the start. not in Rust

A Regex stores no search position. find_at(TEXT, start) takes an explicit start offset instead.

doc Not run on an engine: taken from the documentation.

who has it
n/a Keep the matched text for laterAsk for the matched text, and the text around it, to be saved. not in Rust

No such option. A Match carries the byte offsets of the match, from which the text before and after can be sliced.

doc Not run on an engine: taken from the documentation.

who has it
n/a Interpolate and compile only onceA pattern literal with variables in it is built the first time and never again. not in Rust

No pattern literal and no interpolation. regex!(PATTERN) or a LazyLock<Regex> static compiles the pattern on first use and reuses it.

doc Not run on an engine: taken from the documentation.

who has it
n/a Code inside a patternHost-language code that runs when the match reaches it. not in Rust

doc Not run on an engine: taken from the documentation.

who has it
n/a Pattern computed during the matchCode inside the pattern whose result is matched as a pattern at that point. not in Rust

doc Not run on an engine: taken from the documentation.

who has it

Every row was run on the engine named above, except the rows marked doc: those describe something no regex engine can run by itself, such as the syntax of the host language, and are taken from the documentation they link to. For a row marked "not in Rust", the spelling other dialects use was tried and the line starting "Tried" says what it did here; that shows the spelling does not work, not that no other spelling exists.