Enum Parser 

#[non_exhaustive]
pub enum Parser<I: Clone + Ord> {
    Immediate(Graph<I>),
    Postponed,
    PostponedReference(*const Self),
    Or(Box<Self>, Box<Self>),
    ShrEps(Box<Self>, Box<Self>),
    ShrNonEps(Box<Self>, (I, Option<&'static str>, Box<Self>)),
    Repeat(Box<Self>),
}

Unevaluated binary operation.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Immediate(Graph<I>)

NFA already made.

Postponed

NFA promised.

PostponedReference(*const Self)

NFA promised.

Or(Box<Self>, Box<Self>)

Either one NFA or another, in parallel.

ShrEps(Box<Self>, Box<Self>)

One then an epsilon transition to another.

ShrNonEps(Box<Self>, (I, Option<&'static str>, Box<Self>))

One then a non-epsilon transition (on a particular token) to another.

Repeat(Box<Self>)

Repeat an NFA.

Implementations

impl<I: Clone + Ord> Lazy<I>

pub fn finally(&mut self, value: Self)

Define a postponed value.

Panics

If this value was already defined or if the definition is still postponed.

pub fn compile(self) -> Graph<I>

Brzozowski’s algorithm for minimizing automata.

pub fn repeat(self) -> Self

Match at least one time, then as many times as we want. Note that if ANY number of times leads to an accepting state, we take it!

pub fn optional(self) -> Self

Match at most one time (i.e. ignore if not present).

pub fn star(self) -> Self

Match zero or more times (a.k.a. Kleene star).

pub fn evaluate(self) -> Nfa<I>

Turn an expression into a value. Note that this requires all postponed terms to be present.

Panics

If we postponed a value and never defined it.

Trait Implementations

impl Add for Lazy<char>

type Output = Lazy<char>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<I: Clone + Ord> BitOr for Lazy<I>

type Output = Lazy<I>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<I: Clone + Ord> Clone for Lazy<I>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Debug + Clone + Ord> Debug for Lazy<I>

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

Formats the value using the given formatter.

impl<I: Hash + Clone + Ord> Hash for Lazy<I>

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<I: Ord + Clone + Ord> Ord for Lazy<I>

fn cmp(&self, other: &Lazy<I>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<I: PartialEq + Clone + Ord> PartialEq for Lazy<I>

fn eq(&self, other: &Lazy<I>) -> 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<I: PartialOrd + Clone + Ord> PartialOrd for Lazy<I>

fn partial_cmp(&self, other: &Lazy<I>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<I: Clone + Ord> Shr<(I, Option<&'static str>, Lazy<I>)> for Lazy<I>

type Output = Lazy<I>

The resulting type after applying the >> operator.

fn shr( self, (token, fn_name, rhs): (I, Option<&'static str>, Self), ) -> Self::Output

Performs the >> operation.

impl<I: Clone + Ord> Shr for Lazy<I>

type Output = Lazy<I>

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<I: Eq + Clone + Ord> Eq for Lazy<I>

impl<I: Clone + Ord> StructuralPartialEq for Lazy<I>