Enum ExpressionEnum

pub enum ExpressionEnum {
    Number(Number),
    Str(Str),
    Identifier(Identifier),
    False(False),
    True(True),
    Nil(Nil),
    Group(Group),
    Map(Map),
    Block(Block),
    If(If),
    While(While),
    Function(Function),
    Check(Check),
    For(For),
    Assignment(Assignment),
    AdditionAssignment(AdditionAssignment),
    SubtractionAssignment(SubtractionAssignment),
    MultiplicationAssignment(MultiplicationAssignment),
    DivisionAssignment(DivisionAssignment),
    ModuloAssignment(ModuloAssignment),
    And(And),
    Or(Or),
    Equal(Equal),
    NotEqual(NotEqual),
    Greater(Greater),
    GreaterEqual(GreaterEqual),
    Less(Less),
    LessEqual(LessEqual),
    Range(Range),
    Addition(Addition),
    Subtraction(Subtraction),
    Multiplication(Multiplication),
    Division(Division),
    Modulo(Modulo),
    Not(Not),
    Negate(Negate),
    AsError(AsError),
    Expect(Expect),
    FieldAccess(FieldAccess),
    Index(Index),
    Call(Call),
}

Enum of all expressions.

Variants

Number(Number)

Str(Str)

Identifier(Identifier)

False(False)

True(True)

Nil(Nil)

Group(Group)

Map(Map)

Block(Block)

If(If)

While(While)

Function(Function)

Check(Check)

For(For)

Assignment(Assignment)

AdditionAssignment(AdditionAssignment)

SubtractionAssignment(SubtractionAssignment)

MultiplicationAssignment(MultiplicationAssignment)

DivisionAssignment(DivisionAssignment)

ModuloAssignment(ModuloAssignment)

And(And)

Or(Or)

Equal(Equal)

NotEqual(NotEqual)

Greater(Greater)

GreaterEqual(GreaterEqual)

Less(Less)

LessEqual(LessEqual)

Range(Range)

Addition(Addition)

Subtraction(Subtraction)

Multiplication(Multiplication)

Division(Division)

Modulo(Modulo)

Not(Not)

Negate(Negate)

AsError(AsError)

Expect(Expect)

FieldAccess(FieldAccess)

Index(Index)

Call(Call)

Implementations

impl ExpressionEnum

pub fn name(&self) -> String

Get the name of the expression for debugging purposes.

Trait Implementations

impl AsVariant<Addition> for ExpressionEnum

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

impl AsVariant<AdditionAssignment> for ExpressionEnum

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

impl AsVariant<And> for ExpressionEnum

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

impl AsVariant<AsError> for ExpressionEnum

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

impl AsVariant<Assignment> for ExpressionEnum

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

impl AsVariant<Block> for ExpressionEnum

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

impl AsVariant<Call> for ExpressionEnum

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

impl AsVariant<Check> for ExpressionEnum

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

impl AsVariant<Division> for ExpressionEnum

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

impl AsVariant<DivisionAssignment> for ExpressionEnum

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

impl AsVariant<Equal> for ExpressionEnum

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

impl AsVariant<Expect> for ExpressionEnum

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

impl AsVariant<False> for ExpressionEnum

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

impl AsVariant<FieldAccess> for ExpressionEnum

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

impl AsVariant<For> for ExpressionEnum

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

impl AsVariant<Function> for ExpressionEnum

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

impl AsVariant<Greater> for ExpressionEnum

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

impl AsVariant<GreaterEqual> for ExpressionEnum

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

impl AsVariant<Group> for ExpressionEnum

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

impl AsVariant<Identifier> for ExpressionEnum

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

impl AsVariant<If> for ExpressionEnum

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

impl AsVariant<Index> for ExpressionEnum

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

impl AsVariant<Less> for ExpressionEnum

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

impl AsVariant<LessEqual> for ExpressionEnum

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

impl AsVariant<Map> for ExpressionEnum

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

impl AsVariant<Modulo> for ExpressionEnum

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

impl AsVariant<ModuloAssignment> for ExpressionEnum

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

impl AsVariant<Multiplication> for ExpressionEnum

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

impl AsVariant<MultiplicationAssignment> for ExpressionEnum

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

impl AsVariant<Negate> for ExpressionEnum

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

impl AsVariant<Nil> for ExpressionEnum

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

impl AsVariant<Not> for ExpressionEnum

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

impl AsVariant<NotEqual> for ExpressionEnum

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

impl AsVariant<Number> for ExpressionEnum

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

impl AsVariant<Or> for ExpressionEnum

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

impl AsVariant<Range> for ExpressionEnum

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

impl AsVariant<Str> for ExpressionEnum

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

impl AsVariant<Subtraction> for ExpressionEnum

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

impl AsVariant<SubtractionAssignment> for ExpressionEnum

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

impl AsVariant<True> for ExpressionEnum

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

impl AsVariant<While> for ExpressionEnum

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

impl AsVariantMut<Addition> for ExpressionEnum

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

impl AsVariantMut<AdditionAssignment> for ExpressionEnum

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

impl AsVariantMut<And> for ExpressionEnum

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

impl AsVariantMut<AsError> for ExpressionEnum

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

impl AsVariantMut<Assignment> for ExpressionEnum

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

impl AsVariantMut<Block> for ExpressionEnum

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

impl AsVariantMut<Call> for ExpressionEnum

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

impl AsVariantMut<Check> for ExpressionEnum

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

impl AsVariantMut<Division> for ExpressionEnum

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

impl AsVariantMut<DivisionAssignment> for ExpressionEnum

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

impl AsVariantMut<Equal> for ExpressionEnum

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

impl AsVariantMut<Expect> for ExpressionEnum

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

impl AsVariantMut<False> for ExpressionEnum

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

impl AsVariantMut<FieldAccess> for ExpressionEnum

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

impl AsVariantMut<For> for ExpressionEnum

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

impl AsVariantMut<Function> for ExpressionEnum

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

impl AsVariantMut<Greater> for ExpressionEnum

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

impl AsVariantMut<GreaterEqual> for ExpressionEnum

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

impl AsVariantMut<Group> for ExpressionEnum

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

impl AsVariantMut<Identifier> for ExpressionEnum

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

impl AsVariantMut<If> for ExpressionEnum

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

impl AsVariantMut<Index> for ExpressionEnum

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

impl AsVariantMut<Less> for ExpressionEnum

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

impl AsVariantMut<LessEqual> for ExpressionEnum

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

impl AsVariantMut<Map> for ExpressionEnum

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

impl AsVariantMut<Modulo> for ExpressionEnum

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

impl AsVariantMut<ModuloAssignment> for ExpressionEnum

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

impl AsVariantMut<Multiplication> for ExpressionEnum

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

impl AsVariantMut<MultiplicationAssignment> for ExpressionEnum

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

impl AsVariantMut<Negate> for ExpressionEnum

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

impl AsVariantMut<Nil> for ExpressionEnum

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

impl AsVariantMut<Not> for ExpressionEnum

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

impl AsVariantMut<NotEqual> for ExpressionEnum

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

impl AsVariantMut<Number> for ExpressionEnum

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

impl AsVariantMut<Or> for ExpressionEnum

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

impl AsVariantMut<Range> for ExpressionEnum

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

impl AsVariantMut<Str> for ExpressionEnum

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

impl AsVariantMut<Subtraction> for ExpressionEnum

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

impl AsVariantMut<SubtractionAssignment> for ExpressionEnum

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

impl AsVariantMut<True> for ExpressionEnum

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

impl AsVariantMut<While> for ExpressionEnum

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

impl Clone for ExpressionEnum

fn clone(&self) -> ExpressionEnum

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ExpressionEnum

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

Formats the value using the given formatter.

impl Display for ExpressionEnum

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

Formats the value using the given formatter.

impl Into<ExpressionEnum> for Addition

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for AdditionAssignment

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for And

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for AsError

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for Assignment

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for Block

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for Call

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for Check

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for Division

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for DivisionAssignment

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for Equal

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for Expect

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for False

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for FieldAccess

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for For

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for Function

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for Greater

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for GreaterEqual

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for Group

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for Identifier

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for If

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for Index

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for Less

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for LessEqual

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for Map

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for Modulo

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for ModuloAssignment

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for Multiplication

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for MultiplicationAssignment

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for Negate

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for Nil

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for Not

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for NotEqual

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for Number

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for Or

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for Range

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for Str

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for Subtraction

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for SubtractionAssignment

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for True

fn into(self) -> ExpressionEnum

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

impl Into<ExpressionEnum> for While

fn into(self) -> ExpressionEnum

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

impl IntoVariant<Addition> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<AdditionAssignment> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<And> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<AsError> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Assignment> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Block> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Call> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Check> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Division> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<DivisionAssignment> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Equal> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Expect> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<False> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<FieldAccess> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<For> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Function> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Greater> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<GreaterEqual> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Group> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Identifier> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<If> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Index> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Less> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<LessEqual> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Map> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Modulo> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<ModuloAssignment> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Multiplication> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<MultiplicationAssignment> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Negate> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Nil> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Not> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<NotEqual> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Number> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Or> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Range> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Str> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Subtraction> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<SubtractionAssignment> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<True> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<While> for ExpressionEnum

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

where Self: Sized,

impl PartialEq for ExpressionEnum

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