Enum vyder_core::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),
    Assignement(Assignement),
    AdditionAssignement(AdditionAssignement),
    SubtractionAssignement(SubtractionAssignement),
    MultiplicationAssignement(MultiplicationAssignement),
    DivisionAssignement(DivisionAssignement),
    ModuloAssignement(ModuloAssignement),
    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)

Assignement(Assignement)

AdditionAssignement(AdditionAssignement)

SubtractionAssignement(SubtractionAssignement)

MultiplicationAssignement(MultiplicationAssignement)

DivisionAssignement(DivisionAssignement)

ModuloAssignement(ModuloAssignement)

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<AdditionAssignement> for ExpressionEnum

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

impl AsVariant<And> for ExpressionEnum

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

impl AsVariant<AsError> for ExpressionEnum

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

impl AsVariant<Assignement> for ExpressionEnum

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

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<DivisionAssignement> for ExpressionEnum

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

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<ModuloAssignement> for ExpressionEnum

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

impl AsVariant<Multiplication> for ExpressionEnum

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

impl AsVariant<MultiplicationAssignement> for ExpressionEnum

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

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<SubtractionAssignement> for ExpressionEnum

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

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<AdditionAssignement> for ExpressionEnum

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

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<Assignement> for ExpressionEnum

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

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<DivisionAssignement> for ExpressionEnum

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

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<ModuloAssignement> for ExpressionEnum

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

impl AsVariantMut<Multiplication> for ExpressionEnum

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

impl AsVariantMut<MultiplicationAssignement> for ExpressionEnum

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

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<SubtractionAssignement> for ExpressionEnum

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

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 AdditionAssignement

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 Assignement

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 DivisionAssignement

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 ModuloAssignement

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 MultiplicationAssignement

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 SubtractionAssignement

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<AdditionAssignement> for ExpressionEnum

fn into_variant(self) -> Result<AdditionAssignement, 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<Assignement> for ExpressionEnum

fn into_variant(self) -> Result<Assignement, 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<DivisionAssignement> for ExpressionEnum

fn into_variant(self) -> Result<DivisionAssignement, 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<ModuloAssignement> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<Multiplication> for ExpressionEnum

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

where Self: Sized,

impl IntoVariant<MultiplicationAssignement> for ExpressionEnum

fn into_variant(self) -> Result<MultiplicationAssignement, 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<SubtractionAssignement> for ExpressionEnum

fn into_variant(self) -> Result<SubtractionAssignement, 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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for ExpressionEnum