Struct RegexBuilder 

pub struct RegexBuilder { /* private fields */ }

A builder for configuring and compiling a regex.

Implementations

impl RegexBuilder

pub fn new() -> Self

Create a new builder.

pub fn pattern(self, pattern: &str) -> Self

Set the pattern to match.

Example

use regexr::Regex;

let re = Regex::builder()
    .pattern(r"\d+")
    .build()
    .unwrap();

pub fn engine_type(self, engine_type: EngineType) -> Self

Force a specific engine type.

This method provides a unified API for forcing engine selection, matching the bytes mode API.

Example

use regexr::Regex;
use regexr::engine::EngineType;

let re = Regex::builder()
    .pattern(r"\d+")
    .engine_type(EngineType::Vm)
    .build()
    .unwrap();

pub fn vm(self) -> Self

Force use of the VM (backtracking) engine.

The VM engine supports all regex features including captures and lookarounds.

pub fn case_insensitive(self, yes: bool) -> Self

Enable case-insensitive matching.

pub fn multi_line(self, yes: bool) -> Self

Enable multi-line mode (^ and $ match line boundaries).

pub fn dot_matches_newline(self, yes: bool) -> Self

Make . match newlines.

pub fn unicode(self, yes: bool) -> Self

Enable or disable Unicode mode.

pub fn size_limit(self, limit: usize) -> Self

Set the size limit for the compiled regex.

pub fn prefilter(self, enable: bool) -> Self

Enable or disable SIMD prefiltering.

Prefiltering uses SIMD (memchr/Teddy) to quickly scan for literal substrings before running the full regex engine. This provides significant speedup for:

• Large inputs (>1KB)
• Sparse matches (literal appears rarely)

However, prefiltering adds overhead for:

• Small inputs (<1KB) - setup cost exceeds benefit
• Dense matches - prefilter doesn’t skip much work

Default: disabled (false) - enable explicitly for large input workloads

Example

use regexr::Regex;

// Enable prefiltering for large input workloads
let re = Regex::builder()
    .pattern(r"NEEDLE")
    .prefilter(true)
    .build()
    .unwrap();

// Good for: searching 1MB+ files, log processing, large text analysis
// Not good for: small strings in tight loops

pub fn build(self) -> Result<Regex>

Compile the regex with the configured options.

Errors

Returns an error if the pattern is invalid.

Trait Implementations

impl Clone for RegexBuilder

fn clone(&self) -> RegexBuilder

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RegexBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RegexBuilder

fn default() -> Self

Returns the “default value” for a type.