Enum Token 

pub enum Token<'a> {
    Function(&'a str),
    Comma(&'a str),
    VariableAssign(&'a str),
    VariableRecal(&'a str),
    Constant(&'a str),
    ScientificNotation(&'a str),
    Float(&'a str),
    Int(&'a str),
    PrevAns(&'a str),
    LParen(&'a str),
    RParen(&'a str),
    Equal(&'a str),
    Power(&'a str),
    Multiply(&'a str),
    Divide(&'a str),
    Modulo(&'a str),
    Add(&'a str),
    Subtract(&'a str),
    GreaterThan(&'a str),
    LessThan(&'a str),
    GreaterThanEqualTo(&'a str),
    LessThanEqualTo(&'a str),
    EqualTo(&'a str),
    Negative(&'a str),
}

Variants

Function(&'a str)

Identifier followed by an opening parenthesis

Comma(&'a str)

VariableAssign(&'a str)

Identifier

VariableRecal(&'a str)

$ followed by identifier

Constant(&'a str)

followed by identifier

ScientificNotation(&'a str)

optional int/float

an e followed by an option + or -

1 or more digits (the number following the e)

an optional decimal point followed by 1 or more digits (3.1) or (.1)

Float(&'a str)

Int(&'a str)

PrevAns(&'a str)

An @ signifies the previous answer

LParen(&'a str)

RParen(&'a str)

Equal(&'a str)

Power(&'a str)

Multiply(&'a str)

Divide(&'a str)

Modulo(&'a str)

Add(&'a str)

Subtract(&'a str)

GreaterThan(&'a str)

LessThan(&'a str)

GreaterThanEqualTo(&'a str)

LessThanEqualTo(&'a str)

EqualTo(&'a str)

Negative(&'a str)

This cannot be a token, it is used for differentiation between minus and negative later on in parsing

Trait Implementations

impl<'a> Clone for Token<'a>

fn clone(&self) -> Token<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Token<'a>

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

Formats the value using the given formatter.

impl<'a> Hash for Token<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

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

type Error = ()

Error type returned by the lexer. This can be set using #[logos(error = MyError)]. Defaults to () if not set.

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 PartialEq for Token<'_>

PartialEq implementation that ignores the content of the enum

fn eq(&self, other: &Self) -> 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<'a> Copy for Token<'a>