Enum fancy_regex::Expr

pub enum Expr {
    Empty,
    Any {
        newline: bool,
    },
    StartText,
    EndText,
    StartLine,
    EndLine,
    Literal {
        val: String,
        casei: bool,
    },
    Concat(Vec<Expr>),
    Alt(Vec<Expr>),
    Group(Box<Expr>),
    LookAround(Box<Expr>, LookAround),
    Repeat {
        child: Box<Expr>,
        lo: usize,
        hi: usize,
        greedy: bool,
    },
    Delegate {
        inner: String,
        size: usize,
        casei: bool,
    },
    Backref(usize),
    NamedBackref(String),
    AtomicGroup(Box<Expr>),
}

Regular expression AST. This is public for now but may change.

Variants

Empty

An empty expression, e.g. the last branch in (a|b|)

Any

Fields

newline: bool

Whether it also matches newlines or not

Any character, regex .

StartText

Start of input text

EndText

End of input text

StartLine

Start of a line

EndLine

End of a line

Literal

Fields

val: String

The string to match

casei: bool

Whether match is case-insensitive or not

The string as a literal, e.g. a

Concat(Vec<Expr>)

Tuple Fields

0: Vec<Expr>

Concatenation of multiple expressions, must match in order, e.g. a. is a concatenation of the literal a and . for any character

Alt(Vec<Expr>)

Tuple Fields

0: Vec<Expr>

Alternative of multiple expressions, one of them must match, e.g. a|b is an alternative where either the literal a or b must match

Group(Box<Expr>)

Tuple Fields

0: Box<Expr>

Capturing group of expression, e.g. (a.) matches a and any character and “captures” (remembers) the match

LookAround(Box<Expr>, LookAround)

Tuple Fields

0: Box<Expr>

1: LookAround

Look-around (e.g. positive/negative look-ahead or look-behind) with an expression, e.g. (?=a) means the next character must be a (but the match is not consumed)

Repeat

Fields

child: Box<Expr>

The expression that is being repeated

lo: usize

The minimum number of repetitions

hi: usize

The maximum number of repetitions (or usize::MAX)

greedy: bool

Greedy means as much as possible is matched, e.g. .*b would match all of abab. Non-greedy means as little as possible, e.g. .*?b would match only ab in abab.

Repeat of an expression, e.g. a* or a+ or a{1,3}

Delegate

Fields

inner: String

The regex

size: usize

How many characters the regex matches

casei: bool

Whether the matching is case-insensitive or not

Delegate a regex to the regex crate. This is used as a simplification so that we don’t have to represent all the expressions in the AST, e.g. character classes.

Backref(usize)

Tuple Fields

0: usize

Back reference to a capture group, e.g. \1 in (abc|def)\1 references the captured group and the whole regex matches either abcabc or defdef.

NamedBackref(String)

Tuple Fields

0: String

Back reference to a named capture group.

AtomicGroup(Box<Expr>)

Tuple Fields

0: Box<Expr>

Atomic non-capturing group, e.g. (?>ab|a) in text that contains ab will match ab and never backtrack and try a, even if matching fails after the atomic group.

Implementations

impl Expr

pub fn parse_tree(re: &str) -> Result<ExprTree>

Parse the regex and return an expression (AST) and a bit set with the indexes of groups that are referenced by backrefs.

pub fn to_str(&self, buf: &mut String, precedence: u8)

Convert expression to a regex string in the regex crate’s syntax.

Panics

Panics for expressions that are hard, i.e. can not be handled by the regex crate.

Trait Implementations

impl Debug for Expr

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

Formats the value using the given formatter.

impl PartialEq<Expr> for Expr

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Eq for Expr

impl StructuralEq for Expr

impl StructuralPartialEq for Expr