Standardbibliothek

Antra::Regex

import Antra::Regex

Regex operations for Antra.

Antra::Regex accepts either pattern strings or compiled regex values from Regex.compile(...) / regex"...". The builtin regex?(value) checks whether a runtime value is already a compiled regex.

Überblick#

Für reguläre Ausdrücke und Match-Helfer.

Die zentrale API ist:

import Antra::Regex as Regex

Regex.match("foo bar baz", "\\w+")
Regex.test("hello", "^hel")
Regex.replace("foo foo", "o+", "0")      # nur erster Treffer
Regex.replace_all("a1b2", "\\d", "#")

Regex.replace(...) ersetzt den ersten Treffer, Regex.replace_all(...) alle.

Auch wenn diese Funktionen historisch zusätzlich als globale Built-ins vorhanden sind, ist die Paketform für neue Doku und neuen Code die klarere Lesart.

Referenz#

import Antra::Regex as R

R.compile("^item-[0-9]+$")
R.compile("^item-[0-9]+$").!
R.match("abc123def456", "\\d+")
R.test("hello", "^hel")
R.replace("a1b2", "\\d", "#")
R.replace_all("a1b2", "\\d", "#")

Antra::Regex ist die kleine Regex-Surface der Stdlib. Fuer feste Pattern kannst du direkt String-Pattern oder regex"..."-Literale verwenden. Fuer dynamische Pattern aus Config, Dateien oder User-Input ist R.compile(...) meist die klarere Form.

Die wichtigsten Formen sind:

R.compile(pattern) liefert %Ok[rx] oder %Err[...]
R.compile(pattern).! liefert direkt ein kompiliertes Regex oder wirft
R.match(text, pattern) liefert die aktuelle Match-Liste als Array
R.test(text, pattern) liefert nur true oder false
R.replace(text, pattern, repl) ersetzt den ersten Treffer
R.replace_all(text, pattern, repl) ersetzt alle Treffer

Alle diese Funktionen akzeptieren als pattern entweder einen Pattern-String oder ein bereits kompiliertes Regex.

import Antra::Regex as R

val rx = R.compile("^item-[0-9]+$").!

println(R.test("item-42", rx))
println(R.replace("item-42 item-99", rx, "X"))
println(R.replace_all("item-42 item-99", rx, "X"))

Fuer feste Pattern ist die Literalform oft die kuerzeste Lesart:

Fuer Regex-Muster ist der Backtick-String regex`...` am angenehmsten: Backslashes bleiben literal, \d/\w muessen nicht doppelt escaped werden.

println("hello" =~ regex`^hel`)

if "2026-05-19" =~ regex`(?<year>\d{4})-(\d{2})-(\d{2})` {
    println(year)
    println(_1)
    println(_2)
    println(_3)
}

unless "world" =~ regex`(?<prefix>^wor)(ld)` {
    println("fallback")
} else {
    println(prefix)
    println(_1)
    println(_2)
}

match "2026-05-19" ~? regex`(?<year>\d{4})-(\d{2})-(\d{2})` {
    %Some[parts] -> {
        println(parts[0])     # ganzer Treffer -> "2026-05-19"
        println(parts.year)   # benannte Gruppe -> Keyword-Key
        println(parts[2])     # unbenannte Gruppe -> Gruppennummer
        println(parts[3])
    }
    %None[]      -> println("kein Treffer")
}

Wichtig fuer das aktuelle Verhalten:

R.match(...) liefert kein besonderes Match-Objekt, sondern ein normales Array
text ~? rx liefert bei einem Treffer %Some[...], sonst %None[]. Die Form haengt vom Muster ab: ohne Capture-Gruppen ist es %Some[string] (der getroffene Text); mit Gruppen %Some[map], wobei Key 0 der ganze Treffer ist, benannte Gruppen ((?<name>...)) unter ihrem Namen (map.name) und unbenannte unter ihrer Gruppennummer (map[2]) liegen. Anders als =~ erzeugt ~? keine Variablen-Bindungen, sondern gibt einen Wert zurueck.
if text =~ rx { ... } bindet benannte und nummerierte Captures nur lokal im erfolgreichen Branch
unless text =~ rx { ... } else { ... } bindet dieselben Captures lokal im ausgefuehrten else-Branch
nacktes text =~ rx bleibt trotzdem ein normaler Bool-Ausdruck
R.replace(...) und R.replace_all(...) geben immer neue Strings zurueck und mutieren nicht still

compilefn</>

fn compile(pattern :- String | Regex) :- Result[Regex, Any]

Compiles pattern and returns %Ok[regex] or %Err[...].

matchfn</>

fn match(str :- String, pattern :- String | Regex) :- [String]

Returns the current match payload as an array.

Example:

Regex.match("2026-05-19", "(\\d{4})-(\\d{2})-(\\d{2})")
# => ["2026", "05", "19"]

replacefn</>

fn replace(str :- String, pattern :- String | Regex, repl :- String) :- String

Replaces the first match of pattern in str.

replace_allfn</>

fn replace_all(str :- String, pattern :- String | Regex, repl :- String) :- String

Replaces all matches of pattern in str.

testfn</>

fn test(str :- String, pattern :- String | Regex) :- Bool

Returns true if str matches pattern, otherwise false.

Quelle dieser Seite