Enum NormalToken 

pub enum NormalToken<'input> {
    Error,
    Identifier(&'input str),
    DecNumLiteral(Number),
    HexNumLiteral(Number),
    OctNumLiteral(Number),
    BinNumLiteral(Number),
    RawEnumTag(&'input str),
    StrEnumTagBegin,
    Dyn,
    Number,
    Bool,
    String,
    Array,
    If,
    Then,
    Else,
    Forall,
    In,
    Let,
    Rec,
    Match,
    Null,
    True,
    False,
    Or,
    As,
    Include,
    QuestionMark,
    Comma,
    Semicolon,
    Colon,
    Dollar,
    Equals,
    NotEquals,
    Ampersand,
    Dot,
    DoubleQuote,
    Plus,
    Minus,
    Times,
    Div,
    Percent,
    DoublePlus,
    DoubleEq,
    At,
    DoubleAnd,
    DoublePipe,
    Bang,
    Ellipsis,
    Fun,
    Import,
    Pipe,
    RightPipe,
    SimpleArrow,
    DoubleArrow,
    Underscore,
    MultiStringStart(usize),
    SymbolicStringStart(SymbolicStringStart<'input>),
    Typeof,
    Cast,
    ContractApply,
    ContractCheck,
    ContractArrayLazyApp,
    ContractRecordLazyApp,
    ContractCustom,
    Blame,
    LabelFlipPol,
    LabelPol,
    LabelGoDom,
    LabelGoCodom,
    LabelGoField,
    LabelGoArray,
    LabelGoDict,
    LabelInsertTypeVar,
    LabelLookupTypeVar,
    Seal,
    Unseal,
    EnumEmbed,
    RecordMap,
    RecordInsert,
    RecordInsertWithOpts,
    RecordRemove,
    RecordRemoveWithOpts,
    RecordEmptyWithTail,
    RecordSealTail,
    RecordUnsealTail,
    Seq,
    DeepSeq,
    OpForce,
    ArrayLength,
    RecordFields,
    RecordFieldsWithOpts,
    RecordValues,
    NumberArcCos,
    NumberArcSin,
    NumberArcTan,
    NumberArcTan2,
    NumberCos,
    NumberSin,
    NumberTan,
    NumberLog,
    Pow,
    Trace,
    RecordHasField,
    RecordHasFieldWithOpts,
    ArrayMap,
    ArrayAt,
    ArrayGen,
    OpRecForce,
    OpRecDefault,
    RecordFieldIsDefined,
    RecordFieldIsDefinedWithOpts,
    RecordSplitPair,
    RecordDisjointMerge,
    RecordMergeContract,
    RecordFreeze,
    Default,
    Doc,
    Optional,
    Priority,
    Force,
    NotExported,
    OpHash,
    Serialize,
    Deserialize,
    StringSplit,
    StringTrim,
    StringChars,
    StringUppercase,
    StringLowercase,
    StringContains,
    StringCompare,
    StringReplace,
    StringReplaceRegex,
    StringIsMatch,
    StringFind,
    StringFindAll,
    StringLength,
    StringSubstr,
    StringBase64Encode,
    StringBase64Decode,
    ToString,
    NumberFromString,
    EnumFromString,
    EnumGetArg,
    EnumMakeVariant,
    EnumIsVariant,
    EnumGetTag,
    LabelWithMessage,
    LabelWithNotes,
    LabelAppendNote,
    LabelPushDiag,
    ArraySlice,
    EvalNix,
    LBrace,
    RBrace,
    LBracket,
    RBracket,
    LParen,
    RParen,
    LAngleBracket,
    LessOrEq,
    RAngleBracket,
    GreaterOrEq,
    EnumOpen,
    EnumClose,
    LineComment,
}

The tokens in normal mode.

Variants

Error

Identifier(&'input str)

DecNumLiteral(Number)

HexNumLiteral(Number)

OctNumLiteral(Number)

BinNumLiteral(Number)

RawEnumTag(&'input str)

StrEnumTagBegin

Dyn

Number

Bool

String

Array

If

Then

Else

Forall

In

Let

Rec

Match

Null

True

False

Or

Or isn’t a reserved keyword. It is a contextual keyword (a keyword that can be used as an identifier because it’s not ambiguous) within patterns.

As

As isn’t a reserved keyword. It is a contextual keyword (a keyword that can be used as an identifier because it’s not ambiguous) within the import xxx as yyy construct.

Include

Include isn’t a reserved keyword either. It is a contextual keyword (a keyword that can be used as an identifier because it’s not ambiguous) within a record literal.

QuestionMark

Comma

Semicolon

Colon

Dollar

Equals

NotEquals

Ampersand

Dot

DoubleQuote

Plus

Minus

Times

Div

Percent

DoublePlus

DoubleEq

At

DoubleAnd

DoublePipe

Bang

Ellipsis

Fun

Import

Pipe

RightPipe

SimpleArrow

DoubleArrow

Underscore

MultiStringStart(usize)

SymbolicStringStart(SymbolicStringStart<'input>)

Typeof

Cast

ContractApply

ContractCheck

ContractArrayLazyApp

ContractRecordLazyApp

ContractCustom

Blame

LabelFlipPol

LabelPol

LabelGoDom

LabelGoCodom

LabelGoField

LabelGoArray

LabelGoDict

LabelInsertTypeVar

LabelLookupTypeVar

Seal

Unseal

EnumEmbed

RecordMap

RecordInsert

RecordInsertWithOpts

RecordRemove

RecordRemoveWithOpts

RecordEmptyWithTail

RecordSealTail

RecordUnsealTail

Seq

DeepSeq

OpForce

ArrayLength

RecordFields

RecordFieldsWithOpts

RecordValues

NumberArcCos

NumberArcSin

NumberArcTan

NumberArcTan2

NumberCos

NumberSin

NumberTan

NumberLog

Pow

Trace

RecordHasField

RecordHasFieldWithOpts

ArrayMap

ArrayAt

ArrayGen

OpRecForce

OpRecDefault

RecordFieldIsDefined

RecordFieldIsDefinedWithOpts

RecordSplitPair

RecordDisjointMerge

RecordMergeContract

RecordFreeze

Default

Doc

Optional

Priority

Force

NotExported

OpHash

Serialize

Deserialize

StringSplit

StringTrim

StringChars

StringUppercase

StringLowercase

StringContains

StringCompare

StringReplace

StringReplaceRegex

StringIsMatch

StringFind

StringFindAll

StringLength

StringSubstr

StringBase64Encode

StringBase64Decode

ToString

NumberFromString

EnumFromString

EnumGetArg

EnumMakeVariant

EnumIsVariant

EnumGetTag

LabelWithMessage

LabelWithNotes

LabelAppendNote

LabelPushDiag

ArraySlice

EvalNix

LBrace

RBrace

LBracket

RBracket

LParen

RParen

LAngleBracket

LessOrEq

RAngleBracket

GreaterOrEq

EnumOpen

EnumClose

LineComment

Trait Implementations

impl<'input> Clone for NormalToken<'input>

fn clone(&self) -> NormalToken<'input>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'input> Debug for NormalToken<'input>

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

Formats the value using the given formatter.

impl<'s> Logos<'s> for NormalToken<'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>, ) -> Option<Result<Self, <Self as Logos<'s>>::Error>>

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<'input> PartialEq for NormalToken<'input>

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