Allowing the user to trace lexer results would improve the debugging experience.
This should be implemented similar to the parser trace feature: print the current token after each advance as well as the first token after initializing the lexer.

Create documentation with code examples. The code examples should get tested.

• yalr
  • Document logos_support
• yalr_cli
  • Document all public features
    • table (and options)
    • graph (and options)
• yalr_codegen
  • Document the fact that this is not stable and not fit for public consumption, yet
• yalr_core
  • Document all public types
    • TODO: add checklist
• yalr_proc_macro
  • Document the syntax rules for rule
  • Document terminal_type
  • Document assoc
  • Document lalr

• Fixed/max stack size

When a rule function returns a Result, it should be possible to opt-in to a behavior which stops parsing and propagate the Err value to the caller of the parse function.

Tests are needed, especially for yalr_core.

Unit tests

• yalr_core
  • add checklist here

Integration tests

• All examples should be run as integration tests.

Doc tests

• Code in docs should be tested.

We should get rid of unnecessary attributes and use standard language features over macros whenever possible.

This is a rough sketch of what it could look like:

impl LALR for Parser {
    type T = Terminal;
    type N = Nonterminal;
    const START: Self::N = Nonterminal::Start;
    const END: Self::T = Terminal::End;
    type Input = str;
    type Output = f32;
}

#[lalr]
#[assoc(...)]
impl Parser { /* Rule functions ... */ }

where LALR is a trait defined as:

trait LALR {
    type T;
    type N;
    const START: Self::N;
    const END: Self::T;
    type Input;
    type Output;
}