Enum TokenKind 

pub enum TokenKind {
    Number(String),
    String(String),
    TemplateLiteral(Vec<TemplatePart>),
    Bool(bool),
    Identifier(String),
    Const,
    Fn,
    Export,
    Import,
    From,
    Match,
    Type,
    Opaque,
    Async,
    Await,
    For,
    SelfKw,
    Try,
    Trait,
    Assert,
    When,
    Collect,
    Deriving,
    Use,
    Typeof,
    Ok,
    Err,
    Some,
    None,
    Value,
    Clear,
    Unchanged,
    Parse,
    Mock,
    Todo,
    Unreachable,
    Pipe,
    ThinArrow,
    LeftArrow,
    FatArrow,
    VerticalBar,
    Question,
    Underscore,
    DotDot,
    DotDotDot,
    Plus,
    Minus,
    Star,
    Slash,
    Percent,
    EqualEqual,
    BangEqual,
    LessThan,
    GreaterThan,
    LessEqual,
    GreaterEqual,
    Amp,
    AmpAmp,
    PipePipe,
    Bang,
    Equal,
    LeftParen,
    RightParen,
    LeftBrace,
    RightBrace,
    LeftBracket,
    RightBracket,
    Comma,
    Dot,
    Colon,
    Semicolon,
    Eof,
    Banned(BannedKeyword),
    Whitespace,
    Comment,
    BlockComment,
}

All possible token types in Floe.

Variants

Number(String)

Integer or float literal: 42, 3.14, 0xFF, 0b1010 Underscore separators (e.g. 1_000) are stripped during lexing.

String(String)

Double-quoted string literal: "hello"

TemplateLiteral(Vec<TemplatePart>)

Template literal: `hello ${name}` — stored as parts between interpolations

Bool(bool)

true or false

Identifier(String)

Any identifier: variable names, type names, etc.

Const

Fn

fn — function declaration keyword

Export

Import

From

Match

Type

Opaque

Async

Await

For

for — for block keyword (grouping functions under a type)

SelfKw

self — explicit receiver parameter in for blocks

Try

try — wrap throwing expression in Result

Trait

trait — trait declaration keyword

Assert

assert — assertion (only valid inside test blocks)

When

when — match arm guard

Collect

collect — error accumulation block

Deriving

deriving — auto-derive trait implementations for record types

Use

use — callback flattening (Gleam-style)

Typeof

typeof — type-level operator to extract the type of a value binding

Ok

Err

Some

None

Value

Clear

Unchanged

Parse

parse — compiler built-in for runtime type validation

Mock

mock — compiler built-in for auto-generating test data from types

Todo

todo — placeholder that panics at runtime, type never

Unreachable

unreachable — asserts unreachable code path, type never

Pipe

|> — pipe operator

ThinArrow

-> — match arm arrow

LeftArrow

<- — use binding arrow

FatArrow

=> — fat arrow (banned, kept for error reporting)

VerticalBar

| — vertical bar (union types)

Question

? — Result/Option unwrap

Underscore

_ — placeholder / wildcard

DotDot

.. — spread in constructors

DotDotDot

... — spread in type definitions (record type composition)

Plus

+

Minus

-

Star

*

Slash

/

Percent

%

EqualEqual

==

BangEqual

!=

LessThan

<

GreaterThan

>

LessEqual

<=

GreaterEqual

>=

Amp

& — intersection type operator

AmpAmp

&&

PipePipe

||

Bang

!

Equal

=

LeftParen

(

RightParen

)

LeftBrace

{

RightBrace

}

LeftBracket

[

RightBracket

]

Comma

,

Dot

.

Colon

:

Semicolon

;

Eof

< in JSX context (reuses LessThan in non-JSX) / in </ or /> is handled by the parser via Slash End of file

Banned(BannedKeyword)

A banned keyword was used — carries the keyword and a help message.

Whitespace

Whitespace (spaces, tabs, newlines)

Comment

Line comment: // ...

BlockComment

Block comment: /* ... */

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

Formats the value using the given formatter.

impl PartialEq for TokenKind

fn eq(&self, other: &TokenKind) -> 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 StructuralPartialEq for TokenKind