Struct Width 

pub struct Width {
    pub min: usize,
    pub max: Option<usize>,
}

The range of character widths a pattern can match.

• min — fewest characters consumed; always finite.
• max — most characters consumed; None means unbounded (*, +, {n,}).

Fields

min: usize

max: Option<usize>

Implementations

impl Width

pub fn fixed(n: usize) -> Self

Fixed width: min == max.

pub fn unbounded(min: usize) -> Self

Unbounded: at least min characters, no upper limit.

pub fn is_fixed(&self) -> bool

true when the pattern always matches the same number of characters.

Examples found in repository

examples/width.rs (line 60)

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 is_nullable(&self) -> bool

true when the pattern can match the empty string.

Examples found in repository

examples/width.rs (line 61)

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 is_unbounded(&self) -> bool

true when there is no upper bound on the match length.

Examples found in repository

examples/width.rs (line 62)

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 Width

fn clone(&self) -> Width

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Width

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

Formats the value using the given formatter.

impl Display for Width

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

Formats the value using the given formatter.

impl Eq for Width

impl PartialEq for Width

fn eq(&self, other: &Width) -> 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 Width