Enum Token 

pub enum Token<'a> {
    SingleLineComment(Cow<'a, str>),
    MultiLineComment(Cow<'a, str>),
    DocComment(Cow<'a, str>),
    KeywordMod,
    KeywordPart,
    KeywordSketch,
    KeywordOp,
    KeywordFn,
    KeywordIf,
    KeywordElse,
    KeywordUse,
    KeywordAs,
    KeywordReturn,
    KeywordPub,
    KeywordConst,
    KeywordProp,
    KeywordInit,
    Identifier(Cow<'a, str>),
    Unit(Cow<'a, str>),
    LiteralInt(Cow<'a, str>),
    LiteralFloat(Cow<'a, str>),
    LiteralBool(bool),
    LiteralString(Cow<'a, str>),
    FormatStringStart,
    FormatStringEnd,
    StringContent(Cow<'a, str>),
    Character(char),
    StringFormatOpen,
    StringFormatClose,
    StringFormatPrecision(Cow<'a, str>),
    StringFormatWidth(Cow<'a, str>),
    SigilColon,
    SigilSemiColon,
    SigilDoubleColon,
    SigilOpenBracket,
    SigilCloseBracket,
    SigilOpenSquareBracket,
    SigilCloseSquareBracket,
    SigilOpenCurlyBracket,
    SigilCloseCurlyBracket,
    SigilHash,
    SigilDot,
    SigilComma,
    SigilDoubleDot,
    SigilAt,
    SigilSingleArrow,
    SigilQuote,
    OperatorAdd,
    OperatorSubtract,
    OperatorMultiply,
    OperatorDivide,
    OperatorUnion,
    OperatorIntersect,
    OperatorPowerXor,
    OperatorGreaterThan,
    OperatorLessThan,
    OperatorGreaterEqual,
    OperatorLessEqual,
    OperatorNear,
    OperatorEqual,
    OperatorNotEqual,
    OperatorAnd,
    OperatorOr,
    OperatorXor,
    OperatorNot,
    OperatorAssignment,
    Error(LexerError),
}

Source token for µcad files

Variants

SingleLineComment(Cow<'a, str>)

A single-line comment, starting with //

MultiLineComment(Cow<'a, str>)

A multi-line comment, starting with /* and ending with */

DocComment(Cow<'a, str>)

A doc-comment, starting with ///

KeywordMod

The mod keyword

KeywordPart

The part keyword

KeywordSketch

The sketch keyword

KeywordOp

The op keyword

KeywordFn

The fn keyword

KeywordIf

The if keyword

KeywordElse

The else keyword

KeywordUse

The use keyword

KeywordAs

The as keyword

KeywordReturn

The return keyword

KeywordPub

The pub keyword

KeywordConst

The const keyword

KeywordProp

The prop keyword

KeywordInit

The init keyword

Identifier(Cow<'a, str>)

An identifier, alphanumeric, starting with either an alpha character or a underscore

Unit(Cow<'a, str>)

A unit identifier

LiteralInt(Cow<'a, str>)

An integer literal

LiteralFloat(Cow<'a, str>)

A float literal

LiteralBool(bool)

A boolean literal

LiteralString(Cow<'a, str>)

A string literal

FormatStringStart

Double-quote indicating the start of a format string

FormatStringEnd

Double-quote indicating the end of a format string

StringContent(Cow<'a, str>)

Literal string content of a format string

Character(char)

Escaped character inside a format string

StringFormatOpen

The start of the format expression inside a format string

StringFormatClose

The end of the format expression inside a format string

StringFormatPrecision(Cow<'a, str>)

The precision specification of the format expression inside a format string

StringFormatWidth(Cow<'a, str>)

The width specification of the format expression inside a format string

SigilColon

The : symbol

SigilSemiColon

The ; symbol

SigilDoubleColon

The :: symbol

SigilOpenBracket

The ( symbol

SigilCloseBracket

The ) symbol

SigilOpenSquareBracket

The [ symbol

SigilCloseSquareBracket

The ] symbol

SigilOpenCurlyBracket

The { symbol

SigilCloseCurlyBracket

The } symbol

SigilHash

The # symbol

SigilDot

The . symbol

SigilComma

The , symbol

SigilDoubleDot

The .. symbol

SigilAt

The @ symbol

SigilSingleArrow

The -> symbol

SigilQuote

The " symbol

OperatorAdd

Add operator: +

OperatorSubtract

Subtract operator: -

OperatorMultiply

Multiply operator: -

OperatorDivide

Divide operator: /

OperatorUnion

Union operator: |

OperatorIntersect

Intersect operator: &

OperatorPowerXor

xor operator: ^

OperatorGreaterThan

Greater-than operator: >

OperatorLessThan

Less-than operator: <

OperatorGreaterEqual

Greater-or-equal operator: >=

OperatorLessEqual

Less-or-equal operator: <=

OperatorNear

Near operator: ~

OperatorEqual

Equal operator: ==

OperatorNotEqual

Not-equal operator: !=

OperatorAnd

And operator: and

OperatorOr

Or operator: or

OperatorXor

Xor operator: `xor’

OperatorNot

Not operator: !

OperatorAssignment

Assignment operator: =

Error(LexerError)

A lexer failure

When encountering an error, the lexer attempts to recover and continue emitting further tokens

Implementations

impl Token<'_>

pub fn into_owned(self) -> Token<'static>

Create an owned version of the token

pub fn kind(&self) -> &'static str

Get a descriptive name or symbol for the token type

pub fn is_error(&self) -> bool

Check if the token is an error

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

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

Formats the value using the given formatter.

impl<'a> PartialEq for Token<'a>

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