Enum Token 

pub enum Token<S> {
    Def,
    Thm,
    LBrk,
    RBrk,
    LPar,
    RPar,
    Colon,
    ColonEq,
    Arrow,
    FatArrow,
    LongArrow,
    Comma,
    Dot,
    Symb(Symb<S>),
    Comment(usize),
    Error,
}

A token generated by the lexer.

Variants

Def

definition

Thm

theorem

LBrk

opening bracket

RBrk

closing bracket

LPar

opening parenthesis

RPar

closing parenthesis

Colon

has type

ColonEq

is defined as

Arrow

product

FatArrow

abstraction

LongArrow

rewrites to

Comma

separate variables in rewrite rule contexts

Dot

terminate command

Symb(Symb<S>)

symbol

Comment(usize)

unclosed comments (the number indicates how many comments are still open)

Error

unrecognised token

Trait Implementations

impl<S: Debug> Debug for Token<S>

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

Formats the value using the given formatter.

impl<S: Display> Display for Token<S>

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

Formats the value using the given formatter.

impl<'s> Logos<'s> for Token<&'s str>

const ERROR: Self = Token::Error

Helper const of the variant marked as #[error].

type Extras = ()

Associated type Extras for the particular lexer. This can be set using #[logos(extras = MyExtras)] and accessed inside callbacks.

type Source = str

Source type this token can be lexed from. This will default to str, unless one of the defined patterns explicitly uses non-unicode byte values or byte slices, in which case that implementation will use [u8].

fn lex(lex: &mut Lexer<'s, Self>)

The heart of Logos. Called by the Lexer. The implementation for this function is generated by the logos-derive crate.

fn lexer(source: &'source Self::Source) -> Lexer<'source, Self>

where Self::Extras: Default,

Create a new instance of a Lexer that will produce tokens implementing this Logos.

fn lexer_with_extras( source: &'source Self::Source, extras: Self::Extras, ) -> Lexer<'source, Self>

Create a new instance of a Lexer with the provided Extras that will produce tokens implementing this Logos.

impl<S: PartialEq> PartialEq for Token<S>

fn eq(&self, other: &Token<S>) -> 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<S: Eq> Eq for Token<S>

impl<S> StructuralPartialEq for Token<S>