Enum TokenEnum

pub enum TokenEnum {
    Number(Number),
    Str(Str),
    Identifier(Identifier),
    LeftParen(LeftParen),
    RightParen(RightParen),
    LeftBrace(LeftBrace),
    RightBrace(RightBrace),
    LeftBracket(LeftBracket),
    RightBracket(RightBracket),
    Pipe(Pipe),
    Comma(Comma),
    Dot(Dot),
    Colon(Colon),
    Semicolon(Semicolon),
    DotDot(DotDot),
    Plus(Plus),
    Minus(Minus),
    Star(Star),
    Slash(Slash),
    Percent(Percent),
    PlusEqual(PlusEqual),
    MinusEqual(MinusEqual),
    StarEqual(StarEqual),
    SlashEqual(SlashEqual),
    PercentEqual(PercentEqual),
    EqualEqual(EqualEqual),
    BangEqual(BangEqual),
    Greater(Greater),
    GreaterEqual(GreaterEqual),
    Less(Less),
    LessEqual(LessEqual),
    Bang(Bang),
    Tilde(Tilde),
    QuestionMark(QuestionMark),
    False(False),
    True(True),
    Nil(Nil),
    If(If),
    Else(Else),
    Check(Check),
    As(As),
    And(And),
    Or(Or),
    Not(Not),
    Function(Function),
    Return(Return),
    Break(Break),
    Continue(Continue),
    Ev(Ev),
    For(For),
    While(While),
    In(In),
    Let(Let),
    Const(Const),
    Equal(Equal),
    Exit(Exit),
    EOF(EOF),
}

Enum of all tokens.

Variants

Number(Number)

Str(Str)

Identifier(Identifier)

LeftParen(LeftParen)

RightParen(RightParen)

LeftBrace(LeftBrace)

RightBrace(RightBrace)

LeftBracket(LeftBracket)

RightBracket(RightBracket)

Pipe(Pipe)

Comma(Comma)

Dot(Dot)

Colon(Colon)

Semicolon(Semicolon)

DotDot(DotDot)

Plus(Plus)

Minus(Minus)

Star(Star)

Slash(Slash)

Percent(Percent)

PlusEqual(PlusEqual)

MinusEqual(MinusEqual)

StarEqual(StarEqual)

SlashEqual(SlashEqual)

PercentEqual(PercentEqual)

EqualEqual(EqualEqual)

BangEqual(BangEqual)

Greater(Greater)

GreaterEqual(GreaterEqual)

Less(Less)

LessEqual(LessEqual)

Bang(Bang)

Tilde(Tilde)

QuestionMark(QuestionMark)

False(False)

True(True)

Nil(Nil)

If(If)

Else(Else)

Check(Check)

As(As)

And(And)

Or(Or)

Not(Not)

Function(Function)

Return(Return)

Break(Break)

Continue(Continue)

Ev(Ev)

For(For)

While(While)

In(In)

Let(Let)

Const(Const)

Equal(Equal)

Exit(Exit)

EOF(EOF)

Implementations

impl TokenEnum

pub fn name(&self) -> String

Get the name of the token for debugging purposes.

Trait Implementations

impl AsVariant<And> for TokenEnum

fn as_variant(&self) -> Option<&And>

impl AsVariant<As> for TokenEnum

fn as_variant(&self) -> Option<&As>

impl AsVariant<Bang> for TokenEnum

fn as_variant(&self) -> Option<&Bang>

impl AsVariant<BangEqual> for TokenEnum

fn as_variant(&self) -> Option<&BangEqual>

impl AsVariant<Break> for TokenEnum

fn as_variant(&self) -> Option<&Break>

impl AsVariant<Check> for TokenEnum

fn as_variant(&self) -> Option<&Check>

impl AsVariant<Colon> for TokenEnum

fn as_variant(&self) -> Option<&Colon>

impl AsVariant<Comma> for TokenEnum

fn as_variant(&self) -> Option<&Comma>

impl AsVariant<Const> for TokenEnum

fn as_variant(&self) -> Option<&Const>

impl AsVariant<Continue> for TokenEnum

fn as_variant(&self) -> Option<&Continue>

impl AsVariant<Dot> for TokenEnum

fn as_variant(&self) -> Option<&Dot>

impl AsVariant<DotDot> for TokenEnum

fn as_variant(&self) -> Option<&DotDot>

impl AsVariant<EOF> for TokenEnum

fn as_variant(&self) -> Option<&EOF>

impl AsVariant<Else> for TokenEnum

fn as_variant(&self) -> Option<&Else>

impl AsVariant<Equal> for TokenEnum

fn as_variant(&self) -> Option<&Equal>

impl AsVariant<EqualEqual> for TokenEnum

fn as_variant(&self) -> Option<&EqualEqual>

impl AsVariant<Ev> for TokenEnum

fn as_variant(&self) -> Option<&Ev>

impl AsVariant<Exit> for TokenEnum

fn as_variant(&self) -> Option<&Exit>

impl AsVariant<False> for TokenEnum

fn as_variant(&self) -> Option<&False>

impl AsVariant<For> for TokenEnum

fn as_variant(&self) -> Option<&For>

impl AsVariant<Function> for TokenEnum

fn as_variant(&self) -> Option<&Function>

impl AsVariant<Greater> for TokenEnum

fn as_variant(&self) -> Option<&Greater>

impl AsVariant<GreaterEqual> for TokenEnum

fn as_variant(&self) -> Option<&GreaterEqual>

impl AsVariant<Identifier> for TokenEnum

fn as_variant(&self) -> Option<&Identifier>

impl AsVariant<If> for TokenEnum

fn as_variant(&self) -> Option<&If>

impl AsVariant<In> for TokenEnum

fn as_variant(&self) -> Option<&In>

impl AsVariant<LeftBrace> for TokenEnum

fn as_variant(&self) -> Option<&LeftBrace>

impl AsVariant<LeftBracket> for TokenEnum

fn as_variant(&self) -> Option<&LeftBracket>

impl AsVariant<LeftParen> for TokenEnum

fn as_variant(&self) -> Option<&LeftParen>

impl AsVariant<Less> for TokenEnum

fn as_variant(&self) -> Option<&Less>

impl AsVariant<LessEqual> for TokenEnum

fn as_variant(&self) -> Option<&LessEqual>

impl AsVariant<Let> for TokenEnum

fn as_variant(&self) -> Option<&Let>

impl AsVariant<Minus> for TokenEnum

fn as_variant(&self) -> Option<&Minus>

impl AsVariant<MinusEqual> for TokenEnum

fn as_variant(&self) -> Option<&MinusEqual>

impl AsVariant<Nil> for TokenEnum

fn as_variant(&self) -> Option<&Nil>

impl AsVariant<Not> for TokenEnum

fn as_variant(&self) -> Option<&Not>

impl AsVariant<Number> for TokenEnum

fn as_variant(&self) -> Option<&Number>

impl AsVariant<Or> for TokenEnum

fn as_variant(&self) -> Option<&Or>

impl AsVariant<Percent> for TokenEnum

fn as_variant(&self) -> Option<&Percent>

impl AsVariant<PercentEqual> for TokenEnum

fn as_variant(&self) -> Option<&PercentEqual>

impl AsVariant<Pipe> for TokenEnum

fn as_variant(&self) -> Option<&Pipe>

impl AsVariant<Plus> for TokenEnum

fn as_variant(&self) -> Option<&Plus>

impl AsVariant<PlusEqual> for TokenEnum

fn as_variant(&self) -> Option<&PlusEqual>

impl AsVariant<QuestionMark> for TokenEnum

fn as_variant(&self) -> Option<&QuestionMark>

impl AsVariant<Return> for TokenEnum

fn as_variant(&self) -> Option<&Return>

impl AsVariant<RightBrace> for TokenEnum

fn as_variant(&self) -> Option<&RightBrace>

impl AsVariant<RightBracket> for TokenEnum

fn as_variant(&self) -> Option<&RightBracket>

impl AsVariant<RightParen> for TokenEnum

fn as_variant(&self) -> Option<&RightParen>

impl AsVariant<Semicolon> for TokenEnum

fn as_variant(&self) -> Option<&Semicolon>

impl AsVariant<Slash> for TokenEnum

fn as_variant(&self) -> Option<&Slash>

impl AsVariant<SlashEqual> for TokenEnum

fn as_variant(&self) -> Option<&SlashEqual>

impl AsVariant<Star> for TokenEnum

fn as_variant(&self) -> Option<&Star>

impl AsVariant<StarEqual> for TokenEnum

fn as_variant(&self) -> Option<&StarEqual>

impl AsVariant<Str> for TokenEnum

fn as_variant(&self) -> Option<&Str>

impl AsVariant<Tilde> for TokenEnum

fn as_variant(&self) -> Option<&Tilde>

impl AsVariant<True> for TokenEnum

fn as_variant(&self) -> Option<&True>

impl AsVariant<While> for TokenEnum

fn as_variant(&self) -> Option<&While>

impl AsVariantMut<And> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut And>

impl AsVariantMut<As> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut As>

impl AsVariantMut<Bang> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Bang>

impl AsVariantMut<BangEqual> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut BangEqual>

impl AsVariantMut<Break> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Break>

impl AsVariantMut<Check> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Check>

impl AsVariantMut<Colon> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Colon>

impl AsVariantMut<Comma> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Comma>

impl AsVariantMut<Const> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Const>

impl AsVariantMut<Continue> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Continue>

impl AsVariantMut<Dot> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Dot>

impl AsVariantMut<DotDot> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut DotDot>

impl AsVariantMut<EOF> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut EOF>

impl AsVariantMut<Else> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Else>

impl AsVariantMut<Equal> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Equal>

impl AsVariantMut<EqualEqual> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut EqualEqual>

impl AsVariantMut<Ev> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Ev>

impl AsVariantMut<Exit> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Exit>

impl AsVariantMut<False> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut False>

impl AsVariantMut<For> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut For>

impl AsVariantMut<Function> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Function>

impl AsVariantMut<Greater> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Greater>

impl AsVariantMut<GreaterEqual> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut GreaterEqual>

impl AsVariantMut<Identifier> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Identifier>

impl AsVariantMut<If> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut If>

impl AsVariantMut<In> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut In>

impl AsVariantMut<LeftBrace> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut LeftBrace>

impl AsVariantMut<LeftBracket> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut LeftBracket>

impl AsVariantMut<LeftParen> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut LeftParen>

impl AsVariantMut<Less> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Less>

impl AsVariantMut<LessEqual> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut LessEqual>

impl AsVariantMut<Let> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Let>

impl AsVariantMut<Minus> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Minus>

impl AsVariantMut<MinusEqual> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut MinusEqual>

impl AsVariantMut<Nil> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Nil>

impl AsVariantMut<Not> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Not>

impl AsVariantMut<Number> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Number>

impl AsVariantMut<Or> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Or>

impl AsVariantMut<Percent> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Percent>

impl AsVariantMut<PercentEqual> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut PercentEqual>

impl AsVariantMut<Pipe> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Pipe>

impl AsVariantMut<Plus> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Plus>

impl AsVariantMut<PlusEqual> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut PlusEqual>

impl AsVariantMut<QuestionMark> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut QuestionMark>

impl AsVariantMut<Return> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Return>

impl AsVariantMut<RightBrace> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut RightBrace>

impl AsVariantMut<RightBracket> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut RightBracket>

impl AsVariantMut<RightParen> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut RightParen>

impl AsVariantMut<Semicolon> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Semicolon>

impl AsVariantMut<Slash> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Slash>

impl AsVariantMut<SlashEqual> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut SlashEqual>

impl AsVariantMut<Star> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Star>

impl AsVariantMut<StarEqual> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut StarEqual>

impl AsVariantMut<Str> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Str>

impl AsVariantMut<Tilde> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut Tilde>

impl AsVariantMut<True> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut True>

impl AsVariantMut<While> for TokenEnum

fn as_variant_mut(&mut self) -> Option<&mut While>

impl Clone for TokenEnum

fn clone(&self) -> TokenEnum

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TokenEnum

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

Formats the value using the given formatter.

impl Display for TokenEnum

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

Formats the value using the given formatter.

impl Into<TokenEnum> for And

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for As

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Bang

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for BangEqual

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Break

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Check

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Colon

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Comma

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Const

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Continue

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Dot

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for DotDot

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for EOF

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Else

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Equal

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for EqualEqual

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Ev

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Exit

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for False

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for For

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Function

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Greater

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for GreaterEqual

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Identifier

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for If

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for In

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for LeftBrace

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for LeftBracket

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for LeftParen

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Less

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for LessEqual

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Let

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Minus

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for MinusEqual

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Nil

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Not

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Number

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Or

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Percent

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for PercentEqual

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Pipe

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Plus

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for PlusEqual

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for QuestionMark

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Return

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for RightBrace

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for RightBracket

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for RightParen

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Semicolon

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Slash

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for SlashEqual

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Star

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for StarEqual

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Str

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for Tilde

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for True

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl Into<TokenEnum> for While

fn into(self) -> TokenEnum

Converts this type into the (usually inferred) input type.

impl IntoVariant<And> for TokenEnum

fn into_variant(self) -> Result<And, Self>

where Self: Sized,

impl IntoVariant<As> for TokenEnum

fn into_variant(self) -> Result<As, Self>

where Self: Sized,

impl IntoVariant<Bang> for TokenEnum

fn into_variant(self) -> Result<Bang, Self>

where Self: Sized,

impl IntoVariant<BangEqual> for TokenEnum

fn into_variant(self) -> Result<BangEqual, Self>

where Self: Sized,

impl IntoVariant<Break> for TokenEnum

fn into_variant(self) -> Result<Break, Self>

where Self: Sized,

impl IntoVariant<Check> for TokenEnum

fn into_variant(self) -> Result<Check, Self>

where Self: Sized,

impl IntoVariant<Colon> for TokenEnum

fn into_variant(self) -> Result<Colon, Self>

where Self: Sized,

impl IntoVariant<Comma> for TokenEnum

fn into_variant(self) -> Result<Comma, Self>

where Self: Sized,

impl IntoVariant<Const> for TokenEnum

fn into_variant(self) -> Result<Const, Self>

where Self: Sized,

impl IntoVariant<Continue> for TokenEnum

fn into_variant(self) -> Result<Continue, Self>

where Self: Sized,

impl IntoVariant<Dot> for TokenEnum

fn into_variant(self) -> Result<Dot, Self>

where Self: Sized,

impl IntoVariant<DotDot> for TokenEnum

fn into_variant(self) -> Result<DotDot, Self>

where Self: Sized,

impl IntoVariant<EOF> for TokenEnum

fn into_variant(self) -> Result<EOF, Self>

where Self: Sized,

impl IntoVariant<Else> for TokenEnum

fn into_variant(self) -> Result<Else, Self>

where Self: Sized,

impl IntoVariant<Equal> for TokenEnum

fn into_variant(self) -> Result<Equal, Self>

where Self: Sized,

impl IntoVariant<EqualEqual> for TokenEnum

fn into_variant(self) -> Result<EqualEqual, Self>

where Self: Sized,

impl IntoVariant<Ev> for TokenEnum

fn into_variant(self) -> Result<Ev, Self>

where Self: Sized,

impl IntoVariant<Exit> for TokenEnum

fn into_variant(self) -> Result<Exit, Self>

where Self: Sized,

impl IntoVariant<False> for TokenEnum

fn into_variant(self) -> Result<False, Self>

where Self: Sized,

impl IntoVariant<For> for TokenEnum

fn into_variant(self) -> Result<For, Self>

where Self: Sized,

impl IntoVariant<Function> for TokenEnum

fn into_variant(self) -> Result<Function, Self>

where Self: Sized,

impl IntoVariant<Greater> for TokenEnum

fn into_variant(self) -> Result<Greater, Self>

where Self: Sized,

impl IntoVariant<GreaterEqual> for TokenEnum

fn into_variant(self) -> Result<GreaterEqual, Self>

where Self: Sized,

impl IntoVariant<Identifier> for TokenEnum

fn into_variant(self) -> Result<Identifier, Self>

where Self: Sized,

impl IntoVariant<If> for TokenEnum

fn into_variant(self) -> Result<If, Self>

where Self: Sized,

impl IntoVariant<In> for TokenEnum

fn into_variant(self) -> Result<In, Self>

where Self: Sized,

impl IntoVariant<LeftBrace> for TokenEnum

fn into_variant(self) -> Result<LeftBrace, Self>

where Self: Sized,

impl IntoVariant<LeftBracket> for TokenEnum

fn into_variant(self) -> Result<LeftBracket, Self>

where Self: Sized,

impl IntoVariant<LeftParen> for TokenEnum

fn into_variant(self) -> Result<LeftParen, Self>

where Self: Sized,

impl IntoVariant<Less> for TokenEnum

fn into_variant(self) -> Result<Less, Self>

where Self: Sized,

impl IntoVariant<LessEqual> for TokenEnum

fn into_variant(self) -> Result<LessEqual, Self>

where Self: Sized,

impl IntoVariant<Let> for TokenEnum

fn into_variant(self) -> Result<Let, Self>

where Self: Sized,

impl IntoVariant<Minus> for TokenEnum

fn into_variant(self) -> Result<Minus, Self>

where Self: Sized,

impl IntoVariant<MinusEqual> for TokenEnum

fn into_variant(self) -> Result<MinusEqual, Self>

where Self: Sized,

impl IntoVariant<Nil> for TokenEnum

fn into_variant(self) -> Result<Nil, Self>

where Self: Sized,

impl IntoVariant<Not> for TokenEnum

fn into_variant(self) -> Result<Not, Self>

where Self: Sized,

impl IntoVariant<Number> for TokenEnum

fn into_variant(self) -> Result<Number, Self>

where Self: Sized,

impl IntoVariant<Or> for TokenEnum

fn into_variant(self) -> Result<Or, Self>

where Self: Sized,

impl IntoVariant<Percent> for TokenEnum

fn into_variant(self) -> Result<Percent, Self>

where Self: Sized,

impl IntoVariant<PercentEqual> for TokenEnum

fn into_variant(self) -> Result<PercentEqual, Self>

where Self: Sized,

impl IntoVariant<Pipe> for TokenEnum

fn into_variant(self) -> Result<Pipe, Self>

where Self: Sized,

impl IntoVariant<Plus> for TokenEnum

fn into_variant(self) -> Result<Plus, Self>

where Self: Sized,

impl IntoVariant<PlusEqual> for TokenEnum

fn into_variant(self) -> Result<PlusEqual, Self>

where Self: Sized,

impl IntoVariant<QuestionMark> for TokenEnum

fn into_variant(self) -> Result<QuestionMark, Self>

where Self: Sized,

impl IntoVariant<Return> for TokenEnum

fn into_variant(self) -> Result<Return, Self>

where Self: Sized,

impl IntoVariant<RightBrace> for TokenEnum

fn into_variant(self) -> Result<RightBrace, Self>

where Self: Sized,

impl IntoVariant<RightBracket> for TokenEnum

fn into_variant(self) -> Result<RightBracket, Self>

where Self: Sized,

impl IntoVariant<RightParen> for TokenEnum

fn into_variant(self) -> Result<RightParen, Self>

where Self: Sized,

impl IntoVariant<Semicolon> for TokenEnum

fn into_variant(self) -> Result<Semicolon, Self>

where Self: Sized,

impl IntoVariant<Slash> for TokenEnum

fn into_variant(self) -> Result<Slash, Self>

where Self: Sized,

impl IntoVariant<SlashEqual> for TokenEnum

fn into_variant(self) -> Result<SlashEqual, Self>

where Self: Sized,

impl IntoVariant<Star> for TokenEnum

fn into_variant(self) -> Result<Star, Self>

where Self: Sized,

impl IntoVariant<StarEqual> for TokenEnum

fn into_variant(self) -> Result<StarEqual, Self>

where Self: Sized,

impl IntoVariant<Str> for TokenEnum

fn into_variant(self) -> Result<Str, Self>

where Self: Sized,

impl IntoVariant<Tilde> for TokenEnum

fn into_variant(self) -> Result<Tilde, Self>

where Self: Sized,

impl IntoVariant<True> for TokenEnum

fn into_variant(self) -> Result<True, Self>

where Self: Sized,

impl IntoVariant<While> for TokenEnum

fn into_variant(self) -> Result<While, Self>

where Self: Sized,

impl PartialEq for TokenEnum

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