Enum rhai::Expr

pub enum Expr {
    DynamicConstant(Box<Dynamic>, Position),
    BoolConstant(bool, Position),
    IntegerConstant(INT, Position),
    FloatConstant(FloatWrapper, Position),
    CharConstant(char, Position),
    StringConstant(ImmutableString, Position),
    FnPointer(ImmutableString, Position),
    Array(Box<StaticVec<Expr>>, Position),
    Map(Box<(StaticVec<(Ident, Expr)>, BTreeMap<Identifier, Dynamic>)>, Position),
    Unit(Position),
    Variable(Box<(Option<NonZeroUsize>, Option<(u64, NamespaceRef)>, Ident)>),
    Property(Box<((Identifier, u64), (Identifier, u64), Ident)>),
    Stmt(Box<StmtBlock>),
    FnCall(Box<FnCallExpr>, Position),
    Dot(Box<BinaryExpr>, Position),
    Index(Box<BinaryExpr>, Position),
    And(Box<BinaryExpr>, Position),
    Or(Box<BinaryExpr>, Position),
    Custom(Box<CustomExpr>, Position),
}

(INTERNALS) An expression sub-tree. Exported under the internals feature only.

Volatile Data Structure

This type is volatile and may change.

Variants

DynamicConstant(Box<Dynamic>, Position)

Dynamic constant. Used to hold either an Array or Map literal for quick cloning. All other primitive data types should use the appropriate variants for better speed.

BoolConstant(bool, Position)

Boolean constant.

IntegerConstant(INT, Position)

Integer constant.

FloatConstant(FloatWrapper, Position)

Floating-point constant.

CharConstant(char, Position)

Character constant.

StringConstant(ImmutableString, Position)

String constant.

FnPointer(ImmutableString, Position)

FnPtr constant.

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

[ expr, … ]

Map(Box<(StaticVec<(Ident, Expr)>, BTreeMap<Identifier, Dynamic>)>, Position)

#{ name:expr, … }

Unit(Position)

()

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

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

Property(Box<((Identifier, u64), (Identifier, u64), Ident)>)

Property access - ((getter, hash), (setter, hash), prop)

Stmt(Box<StmtBlock>)

{ statement … }

FnCall(Box<FnCallExpr>, Position)

func ( expr , … )

Dot(Box<BinaryExpr>, Position)

lhs . rhs

Index(Box<BinaryExpr>, Position)

expr [ expr ]

And(Box<BinaryExpr>, Position)

lhs && rhs

Or(Box<BinaryExpr>, Position)

lhs || rhs

Custom(Box<CustomExpr>, Position)

Custom syntax

Implementations

impl Expr

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_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?

pub fn walk<'a>(
    &'a self,
    path: &mut Vec<ASTNode<'a>>,
    on_node: &mut impl FnMut(&[ASTNode<'_>]) -> bool
) -> bool

Recursively walk this expression. Return false from the callback to terminate the walk.

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a copy of the value.

pub 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 ASTNode<'a>

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

Performs the conversion.

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.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.