std.regex | Topaz

이름	모듈
Match.end →	std.regex →
Match.groups →	std.regex →
Match.named →	std.regex →
Match.start →	std.regex →
Match.text →	std.regex →
Regex.compile →	std.regex →
Regex.find →	std.regex →
Regex.findAll →	std.regex →
Regex.isMatch →	std.regex →
Regex.replaceAll →	std.regex →
Regex.split →	std.regex →

Module

Regex.compile validates a Unicode pattern before searching, splitting, or replacing text. Match values contain UTF-8 byte boundaries and independent capture snapshots.

Why

링크

A compiled pattern keeps one search language and one match sequence across Boolean searches, match extraction, splitting, and replacement.

Availability

링크

Import std.regex in language mode 5.21. The current compiler selects std/regex.tpz for this language mode. Availability in other released editions and inclusion in each installed distribution are Pending.

Exported types

링크

export type Regex = Regex

export type Match = Match

Type members keep the compiler-owned type name shown in their declarations. Importing a module does not create a new type identity.

Public API

Pending contracts

링크

Compile the Unicode regular expression language

링크

규칙topaz.stdlib.contract.regex-compile.rule

Compile the Unicode regular expression language

Regex.compile evaluates its pattern string once and returns Ok containing an immutable compiled pattern. Malformed or unsupported syntax returns Err containing a nonempty explanatory string. Compile errors are data and do not issue a diagnostic. Error wording has no fixed spelling.

Patterns match Unicode scalar values without Unicode normalization. Ordinary characters match themselves. Dot matches any scalar except a line feed. Concatenation, ordered alternation with a vertical bar, capturing groups, and noncapturing groups are supported. The empty pattern and empty alternatives are valid.

Character classes support literal members, inclusive scalar ranges, and a leading caret for negation. An inverted range is invalid. Escape a metacharacter with a backslash to match it literally. The escapes for n, r, and t match line feed, carriage return, and tab.

The quantifiers *, +, and ? mean zero or more, one or more, and zero or one. Counted forms {m}, {m,}, and {m,n} use nonnegative decimal counts with m no greater than n. A following question mark makes a repetition lazy. Unescaped braces outside classes delimit a repetition. Quantifiers require an atom and cannot directly repeat an anchor. Possessive quantifiers are invalid.

A caret and dollar anchor the beginning and end of the input. The escapes \A and \z keep those whole-input meanings. Inline flags i, m, and s select Unicode simple case folding, line anchors, and dot matching line feeds. The forms (?flags) and (?flags:pattern) set flags for the remaining group or a nested group. A minus sign clears subsequent flags.

Case folding uses the C and S mappings in Unicode 16.0 CaseFolding.txt and excludes the locale-specific T mappings and multiscalar F mappings. The m flag also permits a caret after a line feed and a dollar before a line feed. It does not remove a carriage return before that line feed.

Unicode properties use Unicode 16.0. The class \d is Decimal_Number. The class \s is White_Space. The class \w combines Alphabetic, Mark, Decimal_Number, Connector_Punctuation, and Join_Control. Uppercase D, S, and W negate those classes. The escapes \b and \B test a boundary or nonboundary between word and nonword scalars. Missing text at either end is nonword.

The forms \p{name} and \P{name} match or negate a Unicode general category, script, or binary property. Use a category alias, a binary-property alias, or Script= followed by a script alias. Names use Unicode 16.0 aliases and ignore case, spaces, and underscores. An unknown property or value is invalid. Unicode matching cannot be disabled to match a partial UTF-8 sequence.

Named captures use (?<name>pattern). Names are case sensitive unique ASCII identifiers beginning with a letter or underscore and continuing with letters, digits, or underscores. The alternative spelling (?P<name>pattern) is invalid.

Backreferences, lookaround, conditionals, atomic groups, and unknown alphanumeric escapes are invalid. Compile performs no I/O and never changes the pattern string.

이유

A documented Unicode pattern language handles text independently of its UTF-8 encoding. Unicode 16.0 aligns property tests with the text library edition. Simple case folding compares scalars without inserting extra characters or depending on a locale. Excluding backreferences and lookaround preserves a regular language. One named capture spelling avoids an alias while compile errors let applications validate patterns as input.

예제 Compile literals, classes, grouping, and anchors →Return errors for malformed and unsupported pattern syntax →Match bounded repetition →Choose the shortest successful lazy repetition →Apply scoped case, line, and dot flags →Use Unicode digit, word, and whitespace classes →Match a Unicode general category →Use complemented classes and zero-width assertions →Use one named capture spelling →Reject a backreference instead of interpreting it as a literal →

Compile literals, classes, grouping, and anchors

링크

run · running · 검증 · 미실행

main.tpzCompile literals, classes, grouping, and anchors플레이그라운드 열기 →

import std.regex { Regex }
import std.io
match (Regex.compile("^(?:ab)+[0-9]?$")) {
case Ok(pattern) => {
let present = pattern.isMatch("abab2")
let absent = pattern.isMatch("zabab2")
io.writeLine("{present}")
io.writeLine("{absent}")
}
case Err(_) => io.writeLine("compile failed")
}

기대 출력종료 코드 0

true
false

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

true
false

이 예제는 아직 실행하지 않았습니다.

Return errors for malformed and unsupported pattern syntax

링크

run · running · 검증 · 미실행

main.tpzReturn errors for malformed and unsupported pattern syntax플레이그라운드 열기 →

import std.regex { Regex }
import std.io
for text in (["[", "(", "a**", "[z-a]", "(?=a)", "(?<a>x)(?<a>y)", "\\q"]) {
match (Regex.compile(text)) {
case Err(message) => io.writeLine("{message != ""}")
case Ok(_) => io.writeLine("accepted")
}
}

기대 출력종료 코드 0

true
true
true
true
true
true
true

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

true
true
true
true
true
true
true

이 예제는 아직 실행하지 않았습니다.

Match bounded repetition

링크

run · running · 검증 · 미실행

main.tpzMatch bounded repetition플레이그라운드 열기 →

import std.regex { Regex }
import std.io
match (Regex.compile("a\{2,3\}")) {
case Ok(pattern) => {
match (pattern.find("aaaa")) {
case Some(found) => io.writeLine(found.text)
case None() => io.writeLine("no match")
}
}
case Err(_) => io.writeLine("compile failed")
}

기대 출력종료 코드 0

aaa

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

aaa

이 예제는 아직 실행하지 않았습니다.

Choose the shortest successful lazy repetition

링크

run · running · 검증 · 미실행

main.tpzChoose the shortest successful lazy repetition플레이그라운드 열기 →

import std.regex { Regex }
import std.io
match (Regex.compile("a+?")) {
case Ok(pattern) => {
match (pattern.find("aaa")) {
case Some(found) => io.writeLine(found.text)
case None() => io.writeLine("no match")
}
}
case Err(_) => io.writeLine("compile failed")
}

기대 출력종료 코드 0

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

a

이 예제는 아직 실행하지 않았습니다.

Apply scoped case, line, and dot flags

링크

run · running · 검증 · 미실행

main.tpzApply scoped case, line, and dot flags플레이그라운드 열기 →

import std.regex { Regex }
import std.io
function show(patternText: string, text: string) -> () {
match (Regex.compile(patternText)) {
case Ok(pattern) => io.writeLine("{pattern.isMatch(text)}")
case Err(_) => io.writeLine("compile failed")
}
}
show("(?i:ab)", "AB")
show("(?m:^b$)", "a\nb\nc")
show("(?s:a.b)", "a\nb")
show("(?i:σ)", "ς")
show("(?i:ss)", "ß")

기대 출력종료 코드 0

true
true
true
true
false

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

true
true
true
true
false

이 예제는 아직 실행하지 않았습니다.

Use Unicode digit, word, and whitespace classes

링크

run · running · 검증 · 미실행

main.tpzUse Unicode digit, word, and whitespace classes플레이그라운드 열기 →

import std.regex { Regex }
import std.io
function show(patternText: string, text: string) -> () {
match (Regex.compile(patternText)) {
case Ok(pattern) => io.writeLine("{pattern.isMatch(text)}")
case Err(_) => io.writeLine("compile failed")
}
}
show("^\\d+$", "١٢")
show("^\\w+$", "한")
show("^\\s$", " ")

기대 출력종료 코드 0

true
true
true

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

true
true
true

이 예제는 아직 실행하지 않았습니다.

Match a Unicode general category

링크

run · running · 검증 · 미실행

main.tpzMatch a Unicode general category플레이그라운드 열기 →

import std.regex { Regex }
import std.io
match (Regex.compile("^\\p\{Letter\}+$")) {
case Ok(pattern) => {
let present = pattern.isMatch("한α")
io.writeLine("{present}")
}
case Err(_) => io.writeLine("compile failed")
}

기대 출력종료 코드 0

true

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

true

이 예제는 아직 실행하지 않았습니다.

Use complemented classes and zero-width assertions

링크

run · running · 검증 · 미실행

main.tpzUse complemented classes and zero-width assertions플레이그라운드 열기 →

import std.regex { Regex }
import std.io
function show(patternText: string, text: string) -> () {
match (Regex.compile(patternText)) {
case Ok(pattern) => io.writeLine("{pattern.isMatch(text)}")
case Err(_) => io.writeLine("compile failed")
}
}
show("^\\D+$", "abc")
show("\\Aab\\z", "ab")
show("\\bcat\\b", "a cat!")

기대 출력종료 코드 0

true
true
true

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

true
true
true

이 예제는 아직 실행하지 않았습니다.

Use one named capture spelling

링크

run · running · 검증 · 미실행

main.tpzUse one named capture spelling플레이그라운드 열기 →

import std.regex { Regex }
import std.io
for text in (["(?<word>a)", "(?P<word>a)"]) {
match (Regex.compile(text)) {
case Ok(_) => io.writeLine("accepted")
case Err(_) => io.writeLine("invalid pattern")
}
}

기대 출력종료 코드 0

accepted
invalid pattern

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

accepted
invalid pattern

이 예제는 아직 실행하지 않았습니다.

Reject a backreference instead of interpreting it as a literal

링크

run · running · 검증 · 미실행

main.tpzReject a backreference instead of interpreting it as a literal플레이그라운드 열기 →

import std.regex { Regex }
import std.io
match (Regex.compile("(a)\\1")) {
case Err(_) => io.writeLine("invalid pattern")
case Ok(_) => io.writeLine("accepted")
}

기대 출력종료 코드 0

invalid pattern

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

invalid pattern

이 예제는 아직 실행하지 않았습니다.

Search from the left and advance through nonoverlapping matches

링크

규칙topaz.stdlib.contract.regex-search.rule

Search from the left and advance through nonoverlapping matches

Regex.isMatch reports whether a match exists anywhere in the input. Regex.find returns Some containing the first match or None() when no match exists. Regex.findAll returns every nonoverlapping match in search order and returns an empty array when no match exists.

Search begins at the earliest Unicode scalar boundary that permits the complete pattern to match. At that position alternatives are tried in pattern order. Greedy repetitions prefer more scalars and lazy repetitions prefer fewer scalars while still allowing the rest of the pattern to match.

After a nonempty match, findAll resumes at its exclusive end. After an empty match, it resumes at the next Unicode scalar boundary. An empty match directly at the end of the preceding nonempty match is skipped and search advances to the next scalar boundary.

An empty pattern visits every scalar boundary, including both ends. The empty input has one boundary and produces one empty match for an empty pattern. Matching never splits the UTF-8 bytes of a scalar.

Regex.split and Regex.replaceAll use the same ordered match sequence as findAll. Repeated calls start a new search and do not retain a cursor. The input string and compiled pattern are unchanged.

The receiver is evaluated once before the positional arguments, which are evaluated once from left to right. Search does not invoke user callbacks or access external state. No match is an ordinary result and does not produce a diagnostic.

이유

One ordered match sequence makes searching, splitting, and replacement agree. Advancing after an empty match ensures progress without splitting a Unicode scalar. Boolean search is distinct from extracting Match data and does not introduce regex membership through the in operator.

예제 Choose the first successful alternative at the leftmost position →Choose a group alternative that allows the complete pattern to match →Return nonoverlapping matches in input order →Visit each boundary for an empty pattern and the empty input →Skip an empty match directly after a nonempty match →Return no match after scanning a longer valid input →

Choose the first successful alternative at the leftmost position

링크

run · running · 검증 · 미실행

main.tpzChoose the first successful alternative at the leftmost position플레이그라운드 열기 →

import std.regex { Regex }
import std.io
match (Regex.compile("a|ab")) {
case Ok(pattern) => {
match (pattern.find("zab")) {
case Some(found) => io.writeLine("{found.start}:{found.end}:{found.text}")
case None() => io.writeLine("no match")
}
let present = pattern.isMatch("zab")
let absent = pattern.isMatch("zzz")
io.writeLine("{present}:{absent}")
match (pattern.find("zzz")) {
case None() => io.writeLine("none")
case Some(_) => io.writeLine("present")
}
let matches = pattern.findAll("zzz")
io.writeLine("{matches.length}")
}
case Err(_) => io.writeLine("compile failed")
}

기대 출력종료 코드 0

1:2:a
true:false
none
0

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

1:2:a
true:false
none
0

이 예제는 아직 실행하지 않았습니다.

Choose a group alternative that allows the complete pattern to match

링크

run · running · 검증 · 미실행

main.tpzChoose a group alternative that allows the complete pattern to match플레이그라운드 열기 →

import std.regex { Regex }
import std.io
match (Regex.compile("(a|ab)c")) {
case Ok(pattern) => {
match (pattern.find("abc")) {
case Some(found) => io.writeLine(found.text)
case None() => io.writeLine("no match")
}
}
case Err(_) => io.writeLine("compile failed")
}

기대 출력종료 코드 0

abc

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

abc

이 예제는 아직 실행하지 않았습니다.

Return nonoverlapping matches in input order

링크

run · running · 검증 · 미실행

main.tpzReturn nonoverlapping matches in input order플레이그라운드 열기 →

import std.regex { Regex }
import std.io
match (Regex.compile("aa")) {
case Ok(pattern) => {
for found in (pattern.findAll("aaaaa")) {
io.writeLine("{found.start}:{found.end}:{found.text}")
}
}
case Err(_) => io.writeLine("compile failed")
}

기대 출력종료 코드 0

0:2:aa
2:4:aa

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

0:2:aa
2:4:aa

이 예제는 아직 실행하지 않았습니다.

Visit each boundary for an empty pattern and the empty input

링크

run · running · 검증 · 미실행

main.tpzVisit each boundary for an empty pattern and the empty input플레이그라운드 열기 →

import std.regex { Regex }
import std.io
match (Regex.compile("")) {
case Ok(pattern) => {
for found in (pattern.findAll("ab")) {
io.writeLine("{found.start}:{found.end}")
}
io.writeLine("empty input")
for found in (pattern.findAll("")) {
io.writeLine("{found.start}:{found.end}")
}
}
case Err(_) => io.writeLine("compile failed")
}

기대 출력종료 코드 0

0:0
1:1
2:2
empty input
0:0

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

0:0
1:1
2:2
empty input
0:0

이 예제는 아직 실행하지 않았습니다.

Skip an empty match directly after a nonempty match

링크

run · running · 검증 · 미실행

main.tpzSkip an empty match directly after a nonempty match플레이그라운드 열기 →

import std.regex { Regex }
import std.io
match (Regex.compile("a*")) {
case Ok(pattern) => {
for found in (pattern.findAll("ab")) {
io.writeLine("{found.start}:{found.end}:{found.text}")
}
}
case Err(_) => io.writeLine("compile failed")
}

기대 출력종료 코드 0

0:1:a
2:2:

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

0:1:a
2:2:

이 예제는 아직 실행하지 않았습니다.

Return no match after scanning a longer valid input

링크

run · running · 검증 · 미실행

main.tpzReturn no match after scanning a longer valid input플레이그라운드 열기 →

import std.regex { Regex }
import std.io
let mut text = "a"
for step in (0 .. 17) {
text = text + text
}
match (Regex.compile("z")) {
case Ok(pattern) => io.writeLine("{pattern.isMatch(text)}")
case Err(_) => io.writeLine("compile failed")
}

기대 출력종료 코드 0

false

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

false

이 예제는 아직 실행하지 않았습니다.

Read match boundaries and capture snapshots

링크

규칙topaz.stdlib.contract.regex-match.rule

Read match boundaries and capture snapshots

Match.start and Match.end are read-only nonnegative UTF-8 byte offsets in the original input. They follow the inclusive start and exclusive end of byte intervals. Both are scalar boundaries and the end does not exceed the UTF-8 byte length of the input.

Match.text is the matched substring. An empty match has equal start and end and an empty text value. The offsets are not string grapheme indexes. A match may select a combining mark inside a grapheme.

Encoding the original input with encodeUtf8, slicing its bytes from start to end, and calling decodeUtf8 returns Ok containing Match.text. This relationship also holds for non-ASCII input.

Match.groups returns an independent array indexed by capture number. Entry zero is Some containing the entire match. Capturing parentheses are numbered from one in opening-parenthesis order. Named groups participate in the same numbering and noncapturing groups do not.

A nonparticipating capture has value None(). A participating empty capture has value Some containing an empty string. A repeated capture retains the last participating capture in the selected match.

Match.named returns an independent map from capture names to captured strings. A nonparticipating named capture is absent. A participating empty named capture is present with an empty string. Names are inserted in ascending ASCII order.

Reading a Match field evaluates its receiver once and does not modify the Match or input. Mutating a groups array or named map does not affect a later field read. Field access cannot fail for a Match value.

이유

Byte offsets identify every exact match even when a pattern selects part of a grapheme. The byte-slice relationship makes those offsets usable without confusing them with text indexing. Optional numbered captures and omitted named entries distinguish absence from a captured empty string.

예제 Report UTF-8 byte offsets for non-ASCII matches →Recover a match through the byte slice identified by its offsets →Keep capture zero and distinguish missing and empty captures →Omit absent named captures and retain a captured empty string →

Report UTF-8 byte offsets for non-ASCII matches

링크

run · running · 검증 · 미실행

main.tpzReport UTF-8 byte offsets for non-ASCII matches플레이그라운드 열기 →

import std.regex { Regex }
import std.io
function show(patternText: string, text: string) -> () {
match (Regex.compile(patternText)) {
case Ok(pattern) => {
match (pattern.find(text)) {
case Some(found) => io.writeLine("{found.start}:{found.end}:{found.text}")
case None() => io.writeLine("no match")
}
}
case Err(_) => io.writeLine("compile failed")
}
}
show("한", "é한🙂")
show("́", "éx")

기대 출력종료 코드 0

2:5:한
1:3:́

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

2:5:한
1:3:́

이 예제는 아직 실행하지 않았습니다.

Recover a match through the byte slice identified by its offsets

링크

run · running · 검증 · 미실행

main.tpzRecover a match through the byte slice identified by its offsets플레이그라운드 열기 →

import std.regex { Regex }
import std.io
let text = "한x"
match (Regex.compile("한")) {
case Ok(pattern) => {
match (pattern.find(text)) {
case Some(found) => {
let bytes = text.encodeUtf8().slice(found.start, found.end)
match (bytes.decodeUtf8()) {
case Ok(decoded) => io.writeLine(decoded)
case Err(_) => io.writeLine("invalid UTF-8 slice")
}
}
case None() => io.writeLine("no match")
}
}
case Err(_) => io.writeLine("compile failed")
}

기대 출력종료 코드 0

한

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

한

이 예제는 아직 실행하지 않았습니다.

Keep capture zero and distinguish missing and empty captures

링크

run · running · 검증 · 미실행

main.tpzKeep capture zero and distinguish missing and empty captures플레이그라운드 열기 →

import std.regex { Regex }
import std.io
match (Regex.compile("(?<word>a)(b)?()")) {
case Ok(pattern) => {
match (pattern.find("a")) {
case Some(found) => {
io.writeLine("{found.groups.length}")
for group in (found.groups) {
match (group) {
case Some(text) => io.writeLine("some={text}")
case None() => io.writeLine("none")
}
}
}
case None() => io.writeLine("no match")
}
}
case Err(_) => io.writeLine("compile failed")
}

기대 출력종료 코드 0

4
some=a
some=a
none
some=

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

4
some=a
some=a
none
some=

이 예제는 아직 실행하지 않았습니다.

Omit absent named captures and retain a captured empty string

링크

run · running · 검증 · 미실행

main.tpzOmit absent named captures and retain a captured empty string플레이그라운드 열기 →

import std.regex { Regex }
import std.io
match (Regex.compile("(?<z>a)?(?<a>b*)")) {
case Ok(pattern) => {
match (pattern.find("")) {
case Some(found) => {
let mut snapshot = found.named
let hasOptional = snapshot.containsKey("z")
io.writeLine("{hasOptional}")
match (snapshot.get("a")) {
case Some(text) => io.writeLine("some={text}")
case None() => io.writeLine("none")
}
snapshot.insert("a", "changed")
match (found.named.get("a")) {
case Some(text) => io.writeLine("again={text}")
case None() => io.writeLine("none")
}
}
case None() => io.writeLine("no match")
}
}
case Err(_) => io.writeLine("compile failed")
}

기대 출력종료 코드 0

false
some=
again=

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

false
some=
again=

이 예제는 아직 실행하지 않았습니다.

Split and replace using the shared match sequence

링크

규칙topaz.stdlib.contract.regex-transform.rule

Split and replace using the shared match sequence

Regex.split returns the input portions between the matches selected by findAll. Delimiters disappear and capture groups are not inserted. Empty portions at either end and between adjacent delimiters are retained. No match produces an array containing the original input.

Regex.replaceAll replaces the same nonoverlapping matches while copying all text between them unchanged. No match returns the original text. The operation does not search inserted replacement text.

Replacement references use a dollar sign followed by a braced capture number or name. Capture zero denotes the complete match. An unknown or nonparticipating capture expands to an empty string. Two dollar signs produce one literal dollar.

A replacement selector is a nonnegative decimal capture number or an ASCII capture name. Dollar text that is neither a double dollar nor a well-formed braced selector is literal. Unbraced dollar names and numbers do not form references. Expansion is performed once and captured dollar text is not expanded again.

An empty pattern splits at every scalar boundary and inserts replacement text at those same boundaries. The adjacent-empty-match rule from findAll also applies when a nonempty match is followed by an empty candidate.

The receiver is evaluated once before text and replacement arguments, which are evaluated once from left to right. Splitting and replacement leave the original string and Regex unchanged. They have no external effects and do not call a user callback.

이유

Using one match sequence prevents a search from disagreeing with a later replacement. Braced capture references have one spelling and an explicit end, so a capture name cannot absorb following replacement text.

예제 Retain empty split fields without inserting captures →Expand braced capture references and a literal dollar →Preserve text that is not a braced reference →Split and replace at each empty-pattern boundary →Share the adjacent-empty-match rule across transformations →Evaluate receiver and replacement inputs once in source order →

Retain empty split fields without inserting captures

링크

run · running · 검증 · 미실행

main.tpzRetain empty split fields without inserting captures플레이그라운드 열기 →

import std.regex { Regex }
import std.io
match (Regex.compile("(,)")) {
case Ok(pattern) => {
for field in (pattern.split(",a,,b,")) {
io.writeLine("[{field}]")
}
for field in (pattern.split("plain")) {
io.writeLine("[{field}]")
}
}
case Err(_) => io.writeLine("compile failed")
}

기대 출력종료 코드 0

[]
[a]
[]
[b]
[]
[plain]

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

[]
[a]
[]
[b]
[]
[plain]

이 예제는 아직 실행하지 않았습니다.

Expand braced capture references and a literal dollar

링크

run · running · 검증 · 미실행

main.tpzExpand braced capture references and a literal dollar플레이그라운드 열기 →

import std.regex { Regex }
import std.io
match (Regex.compile("(?<word>[a-z]+)([0-9]+)?")) {
case Ok(pattern) => {
let replacement = "$\{word\}/$\{0\}/$\{2\}/$\{missing\}/$$"
io.writeLine(pattern.replaceAll("a1 b", replacement))
io.writeLine(pattern.replaceAll("123", replacement))
}
case Err(_) => io.writeLine("compile failed")
}

기대 출력종료 코드 0

a/a1/1//$ b/b///$
123

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

a/a1/1//$ b/b///$
123

이 예제는 아직 실행하지 않았습니다.

Preserve text that is not a braced reference

링크

run · running · 검증 · 미실행

main.tpzPreserve text that is not a braced reference플레이그라운드 열기 →

import std.regex { Regex }
import std.io
match (Regex.compile("a")) {
case Ok(pattern) => io.writeLine(pattern.replaceAll("a", "$word $1 $ $\{\} $\{bad-name\}"))
case Err(_) => io.writeLine("compile failed")
}

기대 출력종료 코드 0

$word $1 $ ${} ${bad-name}

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

$word $1 $ ${} ${bad-name}

이 예제는 아직 실행하지 않았습니다.

Split and replace at each empty-pattern boundary

링크

run · running · 검증 · 미실행

main.tpzSplit and replace at each empty-pattern boundary플레이그라운드 열기 →

import std.regex { Regex }
import std.io
match (Regex.compile("")) {
case Ok(pattern) => {
for field in (pattern.split("ab")) {
io.writeLine("[{field}]")
}
io.writeLine(pattern.replaceAll("ab", "-"))
}
case Err(_) => io.writeLine("compile failed")
}

기대 출력종료 코드 0

[]
[a]
[b]
[]
-a-b-

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

[]
[a]
[b]
[]
-a-b-

이 예제는 아직 실행하지 않았습니다.

Share the adjacent-empty-match rule across transformations

링크

run · running · 검증 · 미실행

main.tpzShare the adjacent-empty-match rule across transformations플레이그라운드 열기 →

import std.regex { Regex }
import std.io
match (Regex.compile("a*")) {
case Ok(pattern) => {
for field in (pattern.split("ab")) {
io.writeLine("[{field}]")
}
io.writeLine(pattern.replaceAll("ab", "-"))
}
case Err(_) => io.writeLine("compile failed")
}

기대 출력종료 코드 0

[]
[b]
[]
-b-

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

[]
[b]
[]
-b-

이 예제는 아직 실행하지 않았습니다.

Evaluate receiver and replacement inputs once in source order

링크

run · running · 검증 · 미실행

main.tpzEvaluate receiver and replacement inputs once in source order플레이그라운드 열기 →

import std.regex { Regex }
import std.test
import std.io
function makePattern() -> Regex {
io.writeLine("receiver")
return test.assertOk(Regex.compile("a"))
}
function inputText() -> string {
io.writeLine("text")
return "a"
}
function replacementText() -> string {
io.writeLine("replacement")
return "b"
}
io.writeLine(makePattern().replaceAll(inputText(), replacementText()))

기대 출력종료 코드 0

receiver
text
replacement
b

$ topaz run main.tpz · 대상 제품 5.21.3

기대 결과

실행을 마칩니다. 종료 코드 0.

표준 오류 출력 없음.

기대 표준 출력

receiver
text
replacement
b

이 예제는 아직 실행하지 않았습니다.

이 모듈의 API

Module

Why

Availability

Exported types

Public API

Pending contracts

Compile the Unicode regular expression language

Compile the Unicode regular expression language

이유

Compile literals, classes, grouping, and anchors

기대 결과

Return errors for malformed and unsupported pattern syntax

기대 결과

Match bounded repetition

기대 결과

Choose the shortest successful lazy repetition

기대 결과

Apply scoped case, line, and dot flags

기대 결과

Use Unicode digit, word, and whitespace classes

기대 결과

Match a Unicode general category

기대 결과

Use complemented classes and zero-width assertions

기대 결과

Use one named capture spelling

기대 결과

Reject a backreference instead of interpreting it as a literal

기대 결과

Search from the left and advance through nonoverlapping matches

Search from the left and advance through nonoverlapping matches

이유

Choose the first successful alternative at the leftmost position

기대 결과

Choose a group alternative that allows the complete pattern to match

기대 결과

Return nonoverlapping matches in input order

기대 결과

Visit each boundary for an empty pattern and the empty input

기대 결과

Skip an empty match directly after a nonempty match

기대 결과

Return no match after scanning a longer valid input

기대 결과

Read match boundaries and capture snapshots

Read match boundaries and capture snapshots

이유

Report UTF-8 byte offsets for non-ASCII matches

기대 결과

Recover a match through the byte slice identified by its offsets

기대 결과

Keep capture zero and distinguish missing and empty captures

기대 결과

Omit absent named captures and retain a captured empty string

기대 결과

Split and replace using the shared match sequence

Split and replace using the shared match sequence

이유

Retain empty split fields without inserting captures

기대 결과

Expand braced capture references and a literal dollar

기대 결과

Preserve text that is not a braced reference

기대 결과

Split and replace at each empty-pattern boundary

기대 결과

Share the adjacent-empty-match rule across transformations

기대 결과

Evaluate receiver and replacement inputs once in source order

기대 결과