Enum rhai::Token

pub enum Token {
    IntegerConstant(INT),
    FloatConstant(FloatWrapper<FLOAT>),
    DecimalConstant(Decimal),
    Identifier(Box<str>),
    CharConstant(char),
    StringConstant(Box<str>),
    InterpolatedString(Box<str>),
    LeftBrace,
    RightBrace,
    LeftParen,
    RightParen,
    LeftBracket,
    RightBracket,
    Plus,
    UnaryPlus,
    Minus,
    UnaryMinus,
    Multiply,
    Divide,
    Modulo,
    PowerOf,
    LeftShift,
    RightShift,
    SemiColon,
    Colon,
    DoubleColon,
    DoubleArrow,
    Underscore,
    Comma,
    Period,
    ExclusiveRange,
    InclusiveRange,
    MapStart,
    Equals,
    True,
    False,
    Let,
    Const,
    If,
    Else,
    Switch,
    Do,
    While,
    Until,
    Loop,
    For,
    In,
    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(LexError),
    Comment(Box<str>),
    Reserved(Box<str>),
    Custom(Box<str>),
    EOF,
}

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

Variants

IntegerConstant(INT)

Tuple Fields

0: INT

An INT constant.

FloatConstant(FloatWrapper<FLOAT>)

Tuple Fields

0: FloatWrapper<FLOAT>

A FLOAT constant.

Reserved under the no_float feature.

DecimalConstant(Decimal)

Tuple Fields

0: Decimal

A Decimal constant.

Requires the decimal feature.

Identifier(Box<str>)

Tuple Fields

0: Box<str>

An identifier.

CharConstant(char)

Tuple Fields

0: char

A character constant.

StringConstant(Box<str>)

Tuple Fields

0: Box<str>

A string constant.

InterpolatedString(Box<str>)

Tuple Fields

0: Box<str>

An interpolated string.

LeftBrace

{

RightBrace

}

LeftParen

(

RightParen

)

LeftBracket

[

RightBracket

]

Plus

+

UnaryPlus

+ (unary)

Minus

-

UnaryMinus

- (unary)

Multiply

*

Divide

/

Modulo

%

PowerOf

**

LeftShift

<<

RightShift

>>

SemiColon

;

Colon

:

DoubleColon

::

DoubleArrow

=>

Underscore

_

Comma

,

Period

.

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

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(LexError)

Tuple Fields

0: LexError

A lexer error.

Comment(Box<str>)

Tuple Fields

0: Box<str>

A comment block.

Reserved(Box<str>)

Tuple Fields

0: Box<str>

A reserved symbol.

Custom(Box<str>)

Tuple Fields

0: Box<str>

A custom keyword.

EOF

End of the input stream.

Implementations

impl Token

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

Get the literal syntax of the token.

pub fn syntax(&self) -> Cow<'static, str>

Get the syntax of the token.

pub const fn is_op_assignment(&self) -> bool

Is this token an op-assignment operator?

pub const fn map_op_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 make_op_assignment(&self) -> Option<Self>

Get the corresponding op-assignment operator of the token.

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

Reverse lookup a token from a piece of syntax.

pub const fn is_eof(&self) -> bool

pub const fn is_next_unary(&self) -> bool

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

fn from(token: Token) -> Self

Performs the conversion.

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, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<Token> for Token

fn eq(&self, other: &Token) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Token) -> bool

This method tests for !=.

impl StructuralPartialEq for Token