Enum TermKind 

pub enum TermKind {
    Empty,
    Epsilon,
    Class(CharSet),
    Concat(TermId, TermId),
    Union(Arc<[TermId]>),
    Star(TermId),
    Inter(Arc<[TermId]>),
    Not(TermId),
    Assert {
        kind: AssertKind,
        word: u8,
        line: u8,
    },
    LookAhead {
        neg: bool,
        body: TermId,
    },
    LookBehind {
        neg: bool,
        tracker: u8,
    },
}

Shape of a term.

Variants

Empty

The empty language.

Epsilon

Only the empty string.

Class(CharSet)

One symbol from a non-empty set.

Concat(TermId, TermId)

Concatenation; the left side is never itself a Concat.

Union(Arc<[TermId]>)

Union of at least two distinct, sorted, non-Union terms.

Star(TermId)

Kleene star.

Inter(Arc<[TermId]>)

Intersection of at least two distinct, sorted, non-Inter terms.

Not(TermId)

Complement relative to all strings over the universe.

Assert

A zero-width assertion with the indices of its auxiliary sets.

Fields

kind: AssertKind

Which assertion.

word: u8

Index of the word set (NO_AUX when unused).

line: u8

Index of the line-terminator set (NO_AUX when unused).

LookAhead

(?=body) / (?!body).

Fields

neg: bool

Negative form.

body: TermId

The looked-at pattern, complete in itself.

LookBehind

(?<=body) / (?<!body), answered by tracker number tracker.

Fields

neg: bool

Negative form.

tracker: u8

Index into the store’s tracker table.

Trait Implementations

impl Clone for TermKind

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TermKind

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

Formats the value using the given formatter.

impl Eq for TermKind

impl Hash for TermKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for TermKind

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for TermKind