Enum TokenKind 

pub enum TokenKind {
    Ident(String),
    Const,
    Input,
    Extern,
    Shared,
    Volatile,
    Cursor,
    Over,
    Pragma,
    For(String),
    Tile,
    TileBody(String, TileBodyKind),
    Dot,
    IntLit(u64),
    FloatLit(f64),
    StringLit(String),
    ColonEq,
    Eq,
    LParen,
    RParen,
    LBracket,
    RBracket,
    LBrace,
    RBrace,
    Comma,
    Colon,
    Arrow,
    Plus,
    Minus,
    Star,
    Slash,
    Percent,
    Caret,
    StarStar,
    ShiftLeft,
    ShiftRight,
    Ampersand,
    AmpAmp,
    Pipe,
    PipePipe,
    Bang,
    Lt,
    Gt,
    EqEq,
    BangEq,
    LtEq,
    GtEq,
    Eof,
}

The kinds of token the lexer produces.

Variants

Ident(String)

A bare identifier: cycle, hash, temp_lut

Const

const keyword — declares an effectively-const binding. Replaces the former final / init distinction; both surfaces collapsed into one. The value is materialized at the earliest opportunity (compile-time fold if possible, scope-init pull otherwise) and is then immutable for the scope’s lifetime. Independent of provenance: a const binding’s RHS may reference workload params, iter-vars bound by an enclosing comprehension, or other in-scope names — whatever the Polydat compiler can resolve.

Input

input keyword — declares one per-cycle kernel input slot. Surface: input <name>[: <type>] (single) or input (<name>[: <type>], ...) (tuple sugar). Mirrors the module-signature param-list shape.

Extern

extern keyword

Shared

shared keyword

Volatile

volatile keyword. Wire-coloring modifier excluding the binding’s value from hash_const.

Cursor

cursor keyword

Over

over keyword — SRD 71 partition-source binding on cursor declarations: cursor q = range(0, N) over p. Soft keyword: only recognised at statement level after a cursor decl’s constructor expression; in expression position it’s a plain identifier.

Pragma

pragma keyword (module-level directive opening, SRD 15 §“Module-Level Pragmas”). Followed by an Ident naming the pragma. Distinct from line comments so the parser sees pragmas as first-class statements rather than scraping them out of // @pragma: text.

For(String)

for followed by its raw comprehension text (SRD 113). The lexer captures everything after the keyword up to a { at nesting depth zero or the end of the line, whichever comes first, so the comprehension grammar stays owned by the comprehension parser rather than being re-tokenized here.

Tile

tile keyword (SRD 114). The body after := is captured raw into a TokenKind::TileBody when it is a block or heredoc.

TileBody(String, TileBodyKind)

A raw tile body and how it was written.

Dot

. (field access: base.ordinal)

IntLit(u64)

Integer literal: 1000, 0xFF

FloatLit(f64)

Float literal: 72.0, 3.14

StringLit(String)

String literal (contents only, no quotes): "hello {name}"

ColonEq

:= (binding operator, used by every binding shape: cycle bindings, const, shared, volatile)

Eq

= — the extern default (extern name: type = default) and the cursor declaration (cursor name = expr); bindings use :=.

LParen

(

RParen

)

LBracket

[

RBracket

]

LBrace

{

RBrace

}

Comma

,

Colon

:

Arrow

->

Plus

+

Minus

- (both binary subtract and unary negate)

Star

*

Slash

/

Percent

%

Caret

^ (bitwise XOR)

StarStar

** (power)

ShiftLeft

<< (shift left)

ShiftRight

>> (shift right)

Ampersand

& (bitwise AND)

AmpAmp

&& (logical AND — SRD-84 Part 1)

Pipe

| (bitwise OR)

PipePipe

|| (logical OR — SRD-84 Part 1)

Bang

! (unary bitwise NOT)

Lt

< (less-than comparison)

Gt

> (greater-than comparison)

EqEq

== (equal-to comparison)

BangEq

!= (not-equal-to comparison)

LtEq

<= (less-than-or-equal comparison)

GtEq

>= (greater-than-or-equal comparison)

Eof

End of input

Trait Implementations

impl Clone for TokenKind

fn clone(&self) -> TokenKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TokenKind

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

Formats the value using the given formatter.

impl PartialEq for TokenKind

fn eq(&self, other: &TokenKind) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for TokenKind