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)>)

Tuple Fields

0: Box<(INT, Position)>

Integer constant.

FloatConstant(Box<FloatWrapper>)

Tuple Fields

0: Box<FloatWrapper>

Floating-point constant.

CharConstant(Box<(char, Position)>)

Tuple Fields

0: Box<(char, Position)>

Character constant.

StringConstant(Box<(ImmutableString, Position)>)

Tuple Fields

0: Box<(ImmutableString, Position)>

String constant.

FnPointer(Box<(ImmutableString, Position)>)

Tuple Fields

0: Box<(ImmutableString, Position)>

FnPtr constant.

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

Tuple Fields

0: 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)>)

Tuple Fields

0: Box<((ImmutableString, String, String), Position)>

Property access.

Stmt(Box<(Stmt, Position)>)

Tuple Fields

0: Box<(Stmt, Position)>

{ stmt }

Expr(Box<Expr>)

Tuple Fields

0: 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>)>)

Tuple Fields

0: 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)>)

Tuple Fields

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

expr op= expr

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

Tuple Fields

0: Box<(Expr, Expr, Position)>

lhs.rhs

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

Tuple Fields

0: Box<(Expr, Expr, Position)>

expr[expr]

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

Tuple Fields

0: Box<(StaticVec<Expr>, Position)>

[ expr, … ]

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

Tuple Fields

0: Box<(StaticVec<((ImmutableString, Position), Expr)>, Position)>

#{ name:expr, … }

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

Tuple Fields

0: Box<(Expr, Expr, Position)>

lhs in rhs

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

Tuple Fields

0: Box<(Expr, Expr, Position)>

lhs && rhs

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

Tuple Fields

0: Box<(Expr, Expr, Position)>

lhs || rhs

True(Position)

Tuple Fields

0: Position

true

False(Position)

Tuple Fields

0: Position

false

Unit(Position)

Tuple Fields

0: Position

()

Custom(Box<(CustomExpr, Position)>)

Tuple Fields

0: 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.