Resharp 1.0.0

RE#

A high-performance, Symbolic Automata based regex engine with first-class support for intersection and complement operations.

RE# compiles patterns into deterministic automata. All matching is non-backtracking with guaranteed linear-time execution. RE# extends System.Text.RegularExpressions syntax with intersection (&), complement (~), and a universal wildcard (_), enabling patterns that are impossible or impractical to express with standard regex.

web playground | paper | blog post

Install

dotnet add package Resharp

Usage

var re = new Resharp.Regex(@"\w+");
re.IsMatch("hello");         // true
re.Count("one two three");   // 3
re.Replace("a1b2", "X");     // "aXbX"

let re = Resharp.Regex(@"hello.*world")
re.Matches("hello world!")

Syntax extensions

RE# supports standard .NET regex syntax plus three extensions:

_ -- universal wildcard

Matches any character including newlines. Equivalent to [\s\S].

_*       any string (including empty)
_{5,10}  any string of 5-10 characters

& -- intersection

Both sides must match. Intersection has higher precedence than alternation.

_*cat_*&_*dog_*       contains both "cat" and "dog"
_*cat_*&_*dog_*&_{5,30}  ...and is 5-30 characters long

~(...) -- complement

Matches everything the inner pattern does not match.

~(_*\d\d_*)     does not contain two consecutive digits
~(.*\n\n.*)     does not contain a double newline

Combining operators

F.*&~(.*Finn)                starts with 'F', does not end with "Finn"
~(_*\d\d_*)&[a-zA-Z\d]{8,}  8+ alphanumeric, no consecutive digits

Performance

RE# uses Automata-based matching with several optimizations: start-set inference, literal prefix scanning, and optional full DFA precompilation. RE# shares many optimizations with .NET's (and .NonBacktracking even shares some RE# techniques and strengths :^)) but RE# is designed from the ground up and returns a different kind of matches (leftmost-longest).

On curated benchmarks from rebar (AMD Ryzen 7 5800X, .NET 10.0):

RE# particularly excels with large patterns. The "monster" benchmarks test dictionary-sized alternations (thousands of alternatives), case-insensitive unicode matching, and context-windowed variants. Here is a little comparison of RE# with .NET's compiled regex engine on these patterns, you can also find wider comparisons in the paper:

For throughput-critical paths, use ValueMatches for zero-allocation matching and ResharpOptions.HighThroughputDefaults for more aggressive optimization.

let re = Resharp.Regex("pattern", ResharpOptions.HighThroughputDefaults)
use slices = re.ValueMatches(chars)
for s in slices do
    printfn $"match at {s.Index}..{s.Index + s.Length}"

'Is it always faster?'

No, but it can be orders of magnitude faster on large patterns and inputs. RE# is designed for scenarios where regex performance is critical and patterns are complex. If the task is simple enough that you don't need regex at all, RE# may not be the best choice. If you're only searching for a small set of literals, using SearchValues can yield better results. RE# shines when you need the full power of regex with large patterns and inputs.

Documentation

• Syntax reference -- full pattern syntax including &, ~, _
• API reference -- all public types and methods

Examples

Runnable scripts in examples/:

License

MIT