Enum Token 

#[non_exhaustive]
pub enum Token {
    IntegerConstant(INT),
    FloatConstant(Box<(FloatWrapper<FLOAT>, Identifier)>),
    DecimalConstant(Box<(Decimal, Identifier)>),
    Identifier(Box<Identifier>),
    CharConstant(char),
    StringConstant(Box<SmartString<LazyCompact>>),
    InterpolatedString(Box<SmartString<LazyCompact>>),
    LeftBrace,
    RightBrace,
    LeftParen,
    RightParen,
    LeftBracket,
    RightBracket,
    Unit,
    Plus,
    UnaryPlus,
    Minus,
    UnaryMinus,
    Multiply,
    Divide,
    Modulo,
    PowerOf,
    LeftShift,
    RightShift,
    SemiColon,
    Colon,
    DoubleColon,
    DoubleArrow,
    Underscore,
    Comma,
    Period,
    Elvis,
    DoubleQuestion,
    QuestionBracket,
    ExclusiveRange,
    InclusiveRange,
    MapStart,
    Equals,
    True,
    False,
    Let,
    Const,
    If,
    Else,
    Switch,
    Do,
    While,
    Until,
    Loop,
    For,
    In,
    NotIn,
    LessThan,
    GreaterThan,
    LessThanEqualsTo,
    GreaterThanEqualsTo,
    EqualsTo,
    NotEqualsTo,
    Bang,
    Pipe,
    Or,
    XOr,
    Ampersand,
    And,
    Fn,
    Continue,
    Break,
    Return,
    Throw,
    Try,
    Catch,
    PlusAssign,
    MinusAssign,
    MultiplyAssign,
    DivideAssign,
    LeftShiftAssign,
    RightShiftAssign,
    AndAssign,
    OrAssign,
    XOrAssign,
    ModuloAssign,
    PowerOfAssign,
    Private,
    Import,
    Export,
    As,
    LexError(Box<LexError>),
    Comment(Box<String>),
    Reserved(Box<Identifier>),
    Custom(Box<Identifier>),
    EOF,
}

(internals) A Rhai language token. Exported under the internals feature only.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

IntegerConstant(INT)

An INT constant.

FloatConstant(Box<(FloatWrapper<FLOAT>, Identifier)>)

A FLOAT constant, including its text representation.

Reserved under the no_float feature.

DecimalConstant(Box<(Decimal, Identifier)>)

A Decimal constant.

Requires the decimal feature, including its text representation.

Identifier(Box<Identifier>)

An identifier.

CharConstant(char)

A character constant.

StringConstant(Box<SmartString<LazyCompact>>)

A string constant.

InterpolatedString(Box<SmartString<LazyCompact>>)

An interpolated string.

LeftBrace

{

RightBrace

}

LeftParen

(

RightParen

)

LeftBracket

[

RightBracket

]

Unit

()

Plus

+

UnaryPlus

+ (unary)

Minus

-

UnaryMinus

- (unary)

Multiply

*

Divide

/

Modulo

%

PowerOf

**

LeftShift

<<

RightShift

>>

SemiColon

;

Colon

:

DoubleColon

::

DoubleArrow

=>

Underscore

_

Comma

,

Period

.

Elvis

?.

Reserved under the no_object feature.

DoubleQuestion

??

QuestionBracket

?[

Reserved under the no_object feature.

ExclusiveRange

..

InclusiveRange

..=

MapStart

#{

Equals

=

True

true

False

false

Let

let

Const

const

If

if

Else

else

Switch

switch

Do

do

While

while

Until

until

Loop

loop

For

for

In

in

NotIn

!in

LessThan

<

GreaterThan

>

LessThanEqualsTo

<=

GreaterThanEqualsTo

>=

EqualsTo

==

NotEqualsTo

!=

Bang

!

Pipe

|

Or

||

XOr

^

Ampersand

&

And

&&

Fn

fn

Reserved under the no_function feature.

Continue

continue

Break

break

Return

return

Throw

throw

Try

try

Catch

catch

PlusAssign

+=

MinusAssign

-=

MultiplyAssign

*=

DivideAssign

/=

LeftShiftAssign

<<=

RightShiftAssign

>>=

AndAssign

&=

OrAssign

|=

XOrAssign

^=

ModuloAssign

%=

PowerOfAssign

**=

Private

private

Reserved under the no_function feature.

Import

import

Reserved under the no_module feature.

Export

export

Reserved under the no_module feature.

As

as

Reserved under the no_module feature.

LexError(Box<LexError>)

A lexer error.

Comment(Box<String>)

A comment block.

Reserved(Box<Identifier>)

A reserved symbol.

Custom(Box<Identifier>)

A custom keyword.

Not available under no_custom_syntax.

EOF

End of the input stream. Used as a placeholder for the end of input.

Implementations

impl Token

pub const fn is_literal(&self) -> bool

Is the token a literal symbol?

pub const fn literal_syntax(&self) -> &'static str

Get the literal syntax of the token.

Panics

Panics if the token is not a literal symbol.

pub const fn is_op_assignment(&self) -> bool

Is this token an op-assignment operator?

pub const fn get_base_op_from_assignment(&self) -> Option<Self>

Get the corresponding operator of the token if it is an op-assignment operator.

pub const fn has_op_assignment(&self) -> bool

Has this token a corresponding op-assignment operator?

pub const fn convert_to_op_assignment(&self) -> Option<Self>

Get the corresponding op-assignment operator of the token.

pub fn lookup_symbol_from_syntax(syntax: &str) -> Option<Self>

Reverse lookup a symbol token from a piece of syntax.

pub const fn is_next_unary(&self) -> bool

If another operator is after these, it’s probably a unary operator (not sure about fn name).

pub const fn precedence(&self) -> Option<NonZeroU8>

Get the precedence number of the token.

pub const fn is_bind_right(&self) -> bool

Does an expression bind to the right (instead of left)?

pub const fn is_standard_symbol(&self) -> bool

Is this token a standard symbol used in the language?

pub const fn is_standard_keyword(&self) -> bool

Is this token a standard keyword?

pub const fn is_reserved(&self) -> bool

Is this token a reserved keyword or symbol?

pub const fn is_custom(&self) -> bool

Is this token a custom keyword?

Trait Implementations

impl Clone for Token

fn clone(&self) -> Token

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Token

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 From<Token> for String

fn from(token: Token) -> Self

Converts to this type from the input type.

impl Hash for Token

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

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