Enum rhai::Expr

pub enum Expr {
    IntegerConstant(Box<(INT, Position)>),
    FloatConstant(Box<FloatWrapper>),
    CharConstant(Box<(char, Position)>),
    StringConstant(Box<(ImmutableString, Position)>),
    FnPointer(Box<(ImmutableString, Position)>),
    Variable(Box<((String, Position), Option<Box<ModuleRef>>, u64, Option<NonZeroUsize>)>),
    Property(Box<((ImmutableString, String, String), Position)>),
    Stmt(Box<(Stmt, Position)>),
    Expr(Box<Expr>),
    FnCall(Box<((Cow<'static, str>, bool, bool, Position), Option<Box<ModuleRef>>, u64, StaticVec<Expr>, Option<bool>)>),
    Assignment(Box<(Expr, Cow<'static, str>, Expr, Position)>),
    Dot(Box<(Expr, Expr, Position)>),
    Index(Box<(Expr, Expr, Position)>),
    Array(Box<(StaticVec<Expr>, Position)>),
    Map(Box<(StaticVec<((ImmutableString, Position), Expr)>, Position)>),
    In(Box<(Expr, Expr, Position)>),
    And(Box<(Expr, Expr, Position)>),
    Or(Box<(Expr, Expr, Position)>),
    True(Position),
    False(Position),
    Unit(Position),
    Custom(Box<(CustomExpr, Position)>),
}

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

Each variant is at most one pointer in size (for speed), with everything being allocated together in one single tuple.

WARNING

This type is volatile and may change.

Variants

IntegerConstant(Box<(INT, Position)>)

Integer constant.

FloatConstant(Box<FloatWrapper>)

Floating-point constant.

CharConstant(Box<(char, Position)>)

Character constant.

StringConstant(Box<(ImmutableString, Position)>)

String constant.

FnPointer(Box<(ImmutableString, Position)>)

FnPtr constant.

Variable(Box<((String, Position), Option<Box<ModuleRef>>, u64, Option<NonZeroUsize>)>)

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

Property(Box<((ImmutableString, String, String), Position)>)

Property access.

Stmt(Box<(Stmt, Position)>)

{ stmt }

Expr(Box<Expr>)

Wrapped expression - should not be optimized away.

FnCall(Box<((Cow<'static, str>, bool, bool, Position), Option<Box<ModuleRef>>, u64, StaticVec<Expr>, Option<bool>)>)

func(expr, ... ) - ((function name, native_only, capture, position), optional modules, hash, arguments, optional default value) Use Cow<'static, str> because a lot of operators (e.g. ==, >=) are implemented as function calls and the function names are predictable, so no need to allocate a new String.

Assignment(Box<(Expr, Cow<'static, str>, Expr, Position)>)

expr op= expr

Dot(Box<(Expr, Expr, Position)>)

lhs.rhs

Index(Box<(Expr, Expr, Position)>)

expr[expr]

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

[ expr, ... ]

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

#{ name:expr, ... }

In(Box<(Expr, Expr, Position)>)

lhs in rhs

And(Box<(Expr, Expr, Position)>)

lhs && rhs

Or(Box<(Expr, Expr, 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.