Lib.rs

#[vpratt::parser(...)]

This macro reads the TABLE const and generates the full Pratt state machine at compile time.
Applied to an impl block of the parser struct you define. The only required field in that struct is the stream field that carries the peekable iterator of your tokens.

Note: The Table must be declared in the impl to which the #[vpratt::parser] attribute is applied.

#[vpratt::parser(
    stream  = self.stream,
    output  = Expression<'a>,
    item    = Token<'a>,
    token   = TokenKind<'a>,
    error   = Diagnostic<'a>,
    extract = |t: &Token<'a>| t.kind.clone(),
)]
impl<'a> Parser<'a> {
    const TABLE: Table<Self> = Table::new();
        ...
}

#[vpratt::token(...)]

Apply this to your token type — a struct, enum, or type alias. Tells vpratt how to extract the routing token from a stream item, and optionally where the span is.

// item is its own routing token
#[vpratt::token(self)]
pub enum TokenKind { ... }

// item wraps the routing token in a named field
#[vpratt::token(kind, span)]
pub struct Token<'a> {
    pub kind: TokenKind<'a>,
    pub span: Span,
}

// item is a logos tuple — routing token at index 0
#[vpratt::token(0, 1)]
pub type LogosToken = (TokenKind, Span);

When applied, token and extract can be omitted from #vpratt::parser:

// without #[vpratt::token] — explicit
#[vpratt::parser(
    stream  = self.stream,
    item    = Token<'a>,
    token   = TokenKind<'a>,
    output  = Expr,
    extract = |t: &Token<'a>| t.kind.clone(),
)]

// with #[vpratt::token(kind)] — token and extract derived
#[vpratt::parser(
    stream = self.stream,
    item   = Token<'a>,
    output = Expr,
)]

The second form is shorter but both are valid. Use whichever fits your project structure — #[vpratt::token] is purely opt-in.

#[vpratt::handler]