Enum 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),
    AtomicGroup(Box<Expr>),
    KeepOut,
    ContinueFromPreviousMatchEnd,
    BackrefExistsCondition(usize),
    Conditional {
        condition: Box<Expr>,
        true_branch: Box<Expr>,
        false_branch: 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

Any character, regex .

Fields

newline: bool

Whether it also matches newlines or not

StartText

Start of input text

EndText

End of input text

StartLine

Start of a line

EndLine

End of a line

Literal

The string as a literal, e.g. a

Fields

val: String

The string to match

casei: bool

Whether match is case-insensitive or not

Concat(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>)

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>)

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

LookAround(Box<Expr>, 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

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

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.

Delegate

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.

Fields

inner: String

The regex

size: usize

How many characters the regex matches

casei: bool

Whether the matching is case-insensitive or not

Backref(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.

AtomicGroup(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.

KeepOut

Keep matched text so far out of overall match

ContinueFromPreviousMatchEnd

Anchor to match at the position where the previous match ended

BackrefExistsCondition(usize)

Conditional expression based on whether the numbered capture group matched or not

Conditional

If/Then/Else Condition. If there is no Then/Else, these will just be empty expressions.

Fields

condition: Box<Expr>

The conditional expression to evaluate

true_branch: Box<Expr>

What to execute if the condition is true

false_branch: Box<Expr>

What to execute if the condition is false

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 for Expr

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

impl StructuralPartialEq for Expr