Nonterminals in a grammar are tabular, terminal symbols are tabular (as are the EOF-stripped version), terminals are referenceable (can be symbolized), and terminals are also tabular.

Same as CanParse but with second formal parameter representing (StripEOF (Sym t)) aka "sts" (stripped terminal symbol).

Action functions triggered during parsing are given the nonterminal we just matched on, the corresponding list of production elements (grammar symbols) in the RHS of the matched production alternative, and the result of recursively.

A ParseEvent may also be just a terminal matched on, or an epsilon event based heavily on which parsing algorithm is being run.

This data type is one of the data types that tie together terminal (token) types and terminal symbol types. When the parser produces a terminal event, you're seeing a token, but when the parser produces a nonterminal event, you're seeing a production in the grammar firing which contains terminal symbols, not tokens.

An Action as seen by the host language (Haskell) is a function from parse events to an abstract-syntax tree that the function constructs based on which non-terminal or terminal symbol was seen.

An Icon (as used in first and follow sets of the LL1 parser and the shift-reduce table of the LR1 parser) is just a terminal symbol taken from the grammar, or it's an epsilon or EOF.

This is the function defining the (n == Sym t == ts) relationship between the name type of a token, the symbol type of a terminal token (as constructed by the tokenizer), and the terminal symbol type as used by the parser. When a parser wants to compare the symbol of an input token to a terminal symbol found in the grammar, it should convert the token to an icon using this function and then compare icons using Eq because icons throw away the value of a token, leaving only the Eq-able piece that we care about.

The symbol for some tokenize is either just it's name n or the special EOF symbol.

A data type with an EOF constructor. There are two things you can do with a data type that has an EOF:

Ask for the type *without* the EOF at compile time
Ask whether or not an instance is the EOF symbol at runtime

Is this a terminal-symbol icon?

Is this an epsilon icon?

Is this the EOF icon?

Universal Abstract Syntax Tree data type. All internal AST "nodes" have a nonterminal, the grammar production symbols it reduced from, and the resulting recursively defined AST nodes acquired from the parser. Leaf AST nodes can be either an epsilon (when explicit epsilons are used in the grammar) or more importantly a terminal symbol. This is another type that defines the relationship between the terminal token type t and the terminal symbol type (ts == Sym t) where the AST tells you the production rule that fired containing ts as well as the tokens t contained in leaves of the AST.

Default AST-constructor function which just copies over the contents of some parse event into an AST.