Enum ParserAction 

pub enum ParserAction<S, P, A>
where
    S: ParserStateID,
    P: ParserProdID,
    A: ParserAmbigID,
{
    Error,
    Accept,
    Shift(S),
    Reduce(P),
    Ambig(A),
    Goto(S),
}

Parser action used by the parsing automaton.

Represents the next operation the parser should perform, such as shifting, reducing, accepting, etc. Parameterized by identifiers for parser states, productions, and ambiguities.

Type Parameters

• S: Parser state identifier type implementing ParserStateID.
• P: Production identifier type implementing ParserProdID.
• A: Ambiguity identifier type implementing ParserAmbigID.

Variants

Error

Indicates a parsing error.

Accept

Signals successful parsing (accepting the input).

Shift(S)

Shifts the next token and transitions to the given parser state.

Reduce(P)

Reduces by the given production rule.

Ambig(A)

Handles an ambiguity represented by the given ambiguity ID.

Goto(S)

Performs a goto transition to the given parser state.

Trait Implementations

impl<S, P, A> Clone for ParserAction<S, P, A>

where S: ParserStateID + Clone, P: ParserProdID + Clone, A: ParserAmbigID + Clone,

fn clone(&self) -> ParserAction<S, P, A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S, P, A> Debug for ParserAction<S, P, A>

where S: ParserStateID + Debug, P: ParserProdID + Debug, A: ParserAmbigID + Debug,

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

Formats the value using the given formatter.

impl<S, P, A> PartialEq for ParserAction<S, P, A>

where S: ParserStateID + PartialEq, P: ParserProdID + PartialEq, A: ParserAmbigID + PartialEq,

fn eq(&self, other: &ParserAction<S, P, A>) -> 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<S, P, A> Copy for ParserAction<S, P, A>

where S: ParserStateID + Copy, P: ParserProdID + Copy, A: ParserAmbigID + Copy,

impl<S, P, A> Eq for ParserAction<S, P, A>

where S: ParserStateID + Eq, P: ParserProdID + Eq, A: ParserAmbigID + Eq,

impl<S, P, A> StructuralPartialEq for ParserAction<S, P, A>

where S: ParserStateID, P: ParserProdID, A: ParserAmbigID,