regex 0.1.0

Regular expressions for Tessel programs, with the syntax of RE2 (the one Go and Rust use). Matching always takes time in proportion to the text, whatever the pattern, so no pattern can hang a program, even one a user typed in.

import regex

fn main() {
    let date = regex.must("(?P<year>\\d\{4})-(\\d\{2})-(\\d\{2})")
    if let m = date.find("Due 2026-10-31, paid 2026-11-02.") {
        print("{m.text} at {m.start}, year {m.named("year") ?? ""}")
    }
    print(date.replaceAll("Due 2026-10-31.", with: "$3/$2/$\{year}"))
}

2026-10-31 at 4, year 2026
Due 31/10/2026.

Using it

Add it to a project (Tessel 0.10 or later):

tessel add regex

then import regex.

Backslashes and braces in Tessel strings

A pattern is a Tessel string, where a backslash is written \\ and a brace \{. So the pattern \d{3}\.\w+ is written "\\d\{3}\\.\\w+". A closing brace } needs nothing.

Making a pattern

Compile a pattern once and use it many times: compiling does all the work of reading the pattern.

Using a pattern

A Match has start and end (character indexes: its text is text.substring(from: start, to: end)), text, group(i) (group 0 is the whole match; nil for a group that took no part), named(name), and groupStart(i) and groupEnd(i).

let r = regex.must("\\b[a-z]")
print(r.replaceEach("hello big world") { m in m.text.uppercase() })
print(regex.must("\\s*,\\s*").split("a , b,c ,d"))
print(regex.must("[A-Z]\{3}-\\d\{4}").matchesWhole("ABC-1234"))
for m in regex.must("\\d+").findAll("3 apples, 12 pears") {
    print("{m.text} at {m.start}")
}

Hello Big World
["a", "b", "c", "d"]
true
3 at 0
12 at 10

The syntax

Which match is found: the leftmost, and from there the one a backtracking engine would find, trying alternatives in order and repeats greedily (or lazily). That's what Go, Rust, Python and JavaScript agree on.

What isn't there, and why

Backreferences (\1) and lookarounds ((?=…), (?!…), (?<=…), (?<!…)) can't be matched in linear time, so the library refuses them with a message saying so, as RE2, Go and Rust do. Unicode classes like \p{L} aren't there yet.

Unicode

Positions count characters as Tessel does, by code point (an emoji is one character), so they work with substring directly. \w, \d, \s and \b are ASCII, as in RE2. (?i) knows the cases of ASCII, Latin-1, Latin Extended-A, Greek and Cyrillic letters, one to one: (?i)straße doesn't match STRASSE.

Speed

Matching runs every way the pattern could match at once (a Pike VM), so the time is the text's length times at most the pattern's size. On an Apple M5 Pro, a log of 850 000 characters takes about 0.15 to 0.25 s to search with a pattern like (\w+)@(\w+)\.com, and a pattern that starts with a plain character (ERROR) skips ahead to it and takes a few milliseconds. Patterns that take a backtracking engine longer than the age of the universe, like (a+)+$ on a long run of a's, take the same time as any other.

Tests

tessel run tests

checks the library against Go's regexp package on 6 915 cases, every feature on 25 texts plus 3 000 random patterns: which patterns are accepted, every match and the positions of its groups, a replacement, a split, and matchesWhole. Then it tests the API, the error messages, Unicode positions, and that the time grows in proportion to the text. go run tools/oracle/main.go makes the cases again (tests/cases.json) from Go.

What's where

Licence

MIT: see LICENSE.