Enum rhai::Expr

pub enum Expr {
    IntegerConstant(INT, Position),
    FloatConstant(FloatWrapper, Position),
    CharConstant(char, Position),
    StringConstant(Box<IdentX>),
    FnPointer(Box<IdentX>),
    Variable(Box<(Option<NonZeroUsize>, Option<Box<ModuleRef>>, u64, Ident)>),
    Property(Box<((String, String), IdentX)>),
    Stmt(Box<StaticVec<Stmt>>, Position),
    Expr(Box<Expr>),
    FnCall(Box<FnCallInfo>, Position),
    Dot(Box<BinaryExpr>, Position),
    Index(Box<BinaryExpr>, Position),
    Array(Box<StaticVec<Expr>>, Position),
    Map(Box<StaticVec<(IdentX, Expr)>>, Position),
    In(Box<BinaryExpr>, Position),
    And(Box<BinaryExpr>, Position),
    Or(Box<BinaryExpr>, Position),
    True(Position),
    False(Position),
    Unit(Position),
    Custom(Box<CustomExpr>, Position),
}

[INTERNALS] An expression sub-tree. Exported under the internals feature only.

WARNING

This type is volatile and may change.

Variants

IntegerConstant(INT, Position)

Integer constant.

FloatConstant(FloatWrapper, Position)

Floating-point constant.

CharConstant(char, Position)

Character constant.

StringConstant(Box<IdentX>)

String constant.

FnPointer(Box<IdentX>)

FnPtr constant.

Variable(Box<(Option<NonZeroUsize>, Option<Box<ModuleRef>>, u64, Ident)>)

Variable access - (optional index, optional modules, hash, variable name)

Property(Box<((String, String), IdentX)>)

Property access - (getter, setter), prop

Stmt(Box<StaticVec<Stmt>>, Position)

{ stmt }

Expr(Box<Expr>)

Wrapped expression - should not be optimized away.

FnCall(Box<FnCallInfo>, Position)

func(expr, ... )

Dot(Box<BinaryExpr>, Position)

lhs.rhs

Index(Box<BinaryExpr>, Position)

expr[expr]

Array(Box<StaticVec<Expr>>, Position)

[ expr, ... ]

Map(Box<StaticVec<(IdentX, Expr)>>, Position)

#{ name:expr, ... }

In(Box<BinaryExpr>, Position)

lhs in rhs

And(Box<BinaryExpr>, Position)

lhs && rhs

Or(Box<BinaryExpr>, Position)

lhs || rhs

True(Position)

true

False(Position)

false

Unit(Position)

()

Custom(Box<CustomExpr>, Position)

Custom syntax

Implementations

impl Expr

pub fn get_type_id(&self) -> Option<TypeId>

Get the type of an expression.

Returns None if the expression's result type is not constant.

pub fn get_constant_value(&self) -> Option<Dynamic>

Get the Dynamic value of a constant expression.

Returns None if the expression is not constant.

pub fn position(&self) -> Position

Get the Position of the expression.

pub fn set_position(&mut self, new_pos: Position) -> &mut Self

Override the Position of the expression.

pub fn is_pure(&self) -> bool

Is the expression pure?

A pure expression has no side effects.

pub fn is_unit(&self) -> bool

Is the expression the unit () literal?

pub fn is_literal(&self) -> bool

Is the expression a simple constant literal?

pub fn is_constant(&self) -> bool

Is the expression a constant?

pub fn is_valid_postfix(&self, token: &Token) -> bool

Is a particular token allowed as a postfix operator to this expression?

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl Default for Expr

fn default() -> Self

Returns the "default value" for a type.

impl<'a> From<&'a Expr> for Expression<'a>

fn from(expr: &'a Expr) -> Self

Performs the conversion.

impl Hash for Expr

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.