Can Functional Pipelines Transform Regex Construction? A Builder Approach

Start Building a Pattern from an Empty String

Instead of writing a long, hard‑to‑read regex string, the generator begins with an initial value – often an empty string, a separator, or a function that returns a separator – and then successively transforms it through a pipeline of functions.

$pattern = '' |> anyCharacter(...);

Or with a custom separator:

$pattern = '/' |> anyCharacter(...);

Each function receives the current pattern and returns a new pattern, creating a linear, readable construction process.

Managing Character Patterns with an Enum

Common "magic strings" such as .[a-z]\w are encapsulated in an enum to improve readability and reuse.

enum CharacterPattern: string {
    case Any = '.';
    case LowercaseLetter = '[a-z]';
    case Word = '\w';
}

A base function any appends a chosen pattern (defaulting to Any) to the existing pattern.

function any(string $pattern, CharacterPattern|string $add = CharacterPattern::Any): string {
    $addPattern = $add instanceof CharacterPattern ? $add->value : $add;
    return "$pattern$addPattern*";
}

Example usage:

$pattern = '' |> any(...);
$pattern = ''
    |> (fn($p) => any($p, CharacterPattern::LowercaseLetter))
    |> (fn($p) => exact($p, 3));

Encapsulating Quantifiers: exact and atLeast

Quantifiers like {n} and {n,} are wrapped in dedicated functions to avoid manual string concatenation.

function exact(string $pattern, int $times): string {
    return "$pattern{{$times}}";
}
function atLeast(string $pattern, int $times): string {
    return "$pattern{{$times},}";
}

Usage example:

$pattern = ''
    |> (fn($p) => any($p, CharacterPattern::LowercaseLetter))
    |> (fn($p) => exact($p, 3));

Splitting Lookahead to Avoid Deep Nesting

Traditional fluent APIs can produce deeply nested positive lookahead constructs. By separating the start and end of a lookahead into two functions, the pipeline stays flat.

function positiveLookaheadStart(string $pattern, string $inner = ''): string {
    return "$pattern(?=$inner";
}
function positiveLookaheadEnd(string $pattern): string {
    return "$pattern)";
}

Example usage:

$pattern = ''
    |> (fn($p) => positiveLookaheadStart($p, '.*'))
    |> (fn($p) => any($p, '[sunday|monday]'))
    |> positiveLookaheadEnd(...);

Groups and Back‑References

Back‑references come in two forms – numeric ( \1) and named ( \k<name>). A single helper function abstracts both.

function backReference(string $pattern, int|string $add): string {
    $reference = is_string($add) ? "k<$add>" : $add;
    return "$pattern\\$reference";
}

Pros and Cons of the Pipeline Builder Approach

Advantages

Each function has a single responsibility.

No side effects, making reasoning easier.

Low testing cost – functions are small and pure.

Simple to extend with new components.

The construction flow is clear and linear.

Disadvantages

Function names may be less intuitive than a classic fluent API.

Can be over‑engineered for simple regular expressions.

Requires developers to think abstractly about pattern composition.

When Is a Regex Generator Appropriate?

Suitable scenarios

Complex rules that need dynamic assembly.

Projects with multiple contributors.

When modular, reusable regex components are desired.

To reduce the proliferation of magic strings.

Unsuitable scenarios

One‑off simple matches.

Performance‑critical paths where every microsecond counts.

Production environments that generate regexes on every request.

Conclusion

Using a pipeline of pure functions to build regular expressions turns regex creation from a fragile string‑concatenation trick into a composable language‑level construct. It clarifies the construction steps, improves maintainability, and encourages modular design, while reminding developers to weigh the added abstraction against the simplicity of direct regex literals.