Enum Regex 

pub enum Regex {
    Literal(char),
    AnyChar,
    Anchor(Anchor),
    EscapeClass(EscapeClass),
    CharClass(CharClass),
    Group(Box<Regex>, GroupKind),
    Quantifier(Box<Regex>, QuantKind, bool),
    Concat(Vec<Regex>),
    Alternation(Vec<Regex>),
}

A parsed regex AST node.

Variants

Literal(char)

Matches a single literal character, e.g. a.

AnyChar

Matches any character except newline (or including it with s flag): .

Anchor(Anchor)

Zero-width assertion: ^, $, \b, \B.

EscapeClass(EscapeClass)

Predefined character class shorthand: \d, \w, \s and their negations.

CharClass(CharClass)

A character class expression: [abc], [^a-z], [\d\w].

Group(Box<Regex>, GroupKind)

A group: capturing, non-capturing, or a lookaround assertion.

Quantifier(Box<Regex>, QuantKind, bool)

A quantifier applied to a sub-expression. The bool is true for greedy.

Concat(Vec<Regex>)

A sequence of sub-expressions matched one after the other.

Alternation(Vec<Regex>)

An alternation of sub-expressions: a|b|c.

Implementations

impl Regex

pub fn min_width(&self) -> usize

Returns the minimum number of characters this node can match.

Anchors (^, $, \b) and lookarounds contribute zero because they are zero-width assertions.

use re_parser::parse;

assert_eq!(parse(r"\d{2,4}").unwrap().min_width(), 2);
assert_eq!(parse(r"^abc$").unwrap().min_width(), 3); // anchors are zero-width
assert_eq!(parse(r"a*").unwrap().min_width(), 0);

Examples found in repository

examples/width.rs (line 17)

fn report(pattern: &str) {
    match parse(pattern) {
        Err(e) => println!("  {pattern:40}  ERROR: {e}"),
        Ok(ast) => {
            let min = ast.min_width();
            let max = ast.max_width();
            let max_str = max.map_or("∞".to_owned(), |n| n.to_string());
            println!("  {pattern:40}  min={min}  max={max_str}");
        }
    }
}

fn main() {
    println!("=== Fixed-width patterns ===");
    report("abc");
    report(r"\d{4}-\d{2}-\d{2}");           // ISO date → 10
    report(r"#[0-9a-fA-F]{6}");             // CSS hex colour → 7
    report(r"[A-Z]{2}[0-9]{4}");            // plate → 6

    println!("\n=== Variable but bounded patterns ===");
    report(r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}"); // IPv4 → 7..=15
    report(r"https?://");                    // 7..=8
    report(r"[a-zA-Z]{2,8}");               // 2..=8
    report(r"colou?r");                     // 5..=6

    println!("\n=== Unbounded patterns ===");
    report(r"\w+");                          // 1..∞
    report(r".*");                           // 0..∞
    report(r"\S+@\S+\.\S+");               // 5..∞
    report(r"(?:ab)+");                     // 2..∞

    println!("\n=== Anchors and lookarounds are zero-width ===");
    report(r"^hello$");                     // anchors → still 5
    report(r"foo(?=bar)");                  // lookahead → 3
    report(r"(?<=\d)px");                   // lookbehind → 2
    report(r"\bword\b");                    // \b → 4

    println!("\n=== Alternation ===");
    report(r"cat|dog");                     // exactly 3
    report(r"a|bb|ccc");                    // 1..=3
    report(r"yes|no");                      // 2..=3
    report(r"x|\d+");                       // 1..∞

    // ── using pattern_width convenience function ───────────────────────────
    println!("\n=== pattern_width() convenience wrapper ===");
    let w = pattern_width(r"a{2,5}").unwrap();
    println!("  a{{2,5}} => {w}");
    println!("    is_fixed:     {}", w.is_fixed());
    println!("    is_nullable:  {}", w.is_nullable());
    println!("    is_unbounded: {}", w.is_unbounded());

    // ── calling methods on a sub-node ──────────────────────────────────────
    println!("\n=== Inspecting sub-nodes ===");
    let ast = parse(r"(\d{4})-(\d{2})-(\d{2})").unwrap();
    println!("  full pattern  min={} max={:?}", ast.min_width(), ast.max_width());

    // Walk the top-level Concat children manually
    if let re_parser::ast::Regex::Concat(nodes) = &ast {
        for (i, node) in nodes.iter().enumerate() {
            println!(
                "  child[{i}]  min={}  max={:?}  node={node:?}",
                node.min_width(),
                node.max_width(),
            );
        }
    }
}

pub fn max_width(&self) -> Option<usize>

Returns the maximum number of characters this node can match, or None if the match length is unbounded (the node contains *, +, or {n,}).

use re_parser::parse;

assert_eq!(parse(r"\d{2,4}").unwrap().max_width(), Some(4));
assert_eq!(parse(r"a+").unwrap().max_width(), None); // unbounded
assert_eq!(parse(r"foo(?=bar)").unwrap().max_width(), Some(3)); // lookahead is zero-width

Examples found in repository

examples/width.rs (line 18)

fn report(pattern: &str) {
    match parse(pattern) {
        Err(e) => println!("  {pattern:40}  ERROR: {e}"),
        Ok(ast) => {
            let min = ast.min_width();
            let max = ast.max_width();
            let max_str = max.map_or("∞".to_owned(), |n| n.to_string());
            println!("  {pattern:40}  min={min}  max={max_str}");
        }
    }
}

fn main() {
    println!("=== Fixed-width patterns ===");
    report("abc");
    report(r"\d{4}-\d{2}-\d{2}");           // ISO date → 10
    report(r"#[0-9a-fA-F]{6}");             // CSS hex colour → 7
    report(r"[A-Z]{2}[0-9]{4}");            // plate → 6

    println!("\n=== Variable but bounded patterns ===");
    report(r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}"); // IPv4 → 7..=15
    report(r"https?://");                    // 7..=8
    report(r"[a-zA-Z]{2,8}");               // 2..=8
    report(r"colou?r");                     // 5..=6

    println!("\n=== Unbounded patterns ===");
    report(r"\w+");                          // 1..∞
    report(r".*");                           // 0..∞
    report(r"\S+@\S+\.\S+");               // 5..∞
    report(r"(?:ab)+");                     // 2..∞

    println!("\n=== Anchors and lookarounds are zero-width ===");
    report(r"^hello$");                     // anchors → still 5
    report(r"foo(?=bar)");                  // lookahead → 3
    report(r"(?<=\d)px");                   // lookbehind → 2
    report(r"\bword\b");                    // \b → 4

    println!("\n=== Alternation ===");
    report(r"cat|dog");                     // exactly 3
    report(r"a|bb|ccc");                    // 1..=3
    report(r"yes|no");                      // 2..=3
    report(r"x|\d+");                       // 1..∞

    // ── using pattern_width convenience function ───────────────────────────
    println!("\n=== pattern_width() convenience wrapper ===");
    let w = pattern_width(r"a{2,5}").unwrap();
    println!("  a{{2,5}} => {w}");
    println!("    is_fixed:     {}", w.is_fixed());
    println!("    is_nullable:  {}", w.is_nullable());
    println!("    is_unbounded: {}", w.is_unbounded());

    // ── calling methods on a sub-node ──────────────────────────────────────
    println!("\n=== Inspecting sub-nodes ===");
    let ast = parse(r"(\d{4})-(\d{2})-(\d{2})").unwrap();
    println!("  full pattern  min={} max={:?}", ast.min_width(), ast.max_width());

    // Walk the top-level Concat children manually
    if let re_parser::ast::Regex::Concat(nodes) = &ast {
        for (i, node) in nodes.iter().enumerate() {
            println!(
                "  child[{i}]  min={}  max={:?}  node={node:?}",
                node.min_width(),
                node.max_width(),
            );
        }
    }
}

Trait Implementations

impl Clone for Regex

fn clone(&self) -> Regex

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Regex

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

Formats the value using the given formatter.

impl PartialEq for Regex

fn eq(&self, other: &Regex) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Regex