Enum Expr 

#[non_exhaustive]
pub enum Expr {
    DynamicConstant(Box<Dynamic>, Position),
    BoolConstant(bool, Position),
    IntegerConstant(i64, Position),
    FloatConstant(FloatWrapper<f64>, Position),
    CharConstant(char, Position),
    StringConstant(ImmutableString, Position),
    InterpolatedString(ThinVec<Expr>, Position),
    Array(ThinVec<Expr>, Position),
    Map(Box<(SmallVec<[(Ident, Expr); 3]>, BTreeMap<SmartString<LazyCompact>, Dynamic>)>, Position),
    Unit(Position),
    Variable(Box<(Option<NonZero<usize>>, ImmutableString, Namespace, u64)>, Option<NonZero<u8>>, Position),
    ThisPtr(Position),
    Property(Box<((ImmutableString, u64), (ImmutableString, u64), ImmutableString)>, Position),
    MethodCall(Box<FnCallExpr>, Position),
    Stmt(Box<StmtBlock>),
    FnCall(Box<FnCallExpr>, Position),
    Dot(Box<BinaryExpr>, ASTFlags, Position),
    Index(Box<BinaryExpr>, ASTFlags, Position),
    And(Box<SmallVec<[Expr; 3]>>, Position),
    Or(Box<SmallVec<[Expr; 3]>>, Position),
    Coalesce(Box<SmallVec<[Expr; 3]>>, Position),
    Custom(Box<CustomExpr>, Position),
}

Available on crate feature rhai only.

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

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

DynamicConstant(Box<Dynamic>, Position)

Dynamic constant.

Used to hold complex constants such as Array or Map for quick cloning. Primitive data types should use the appropriate variants to avoid an allocation.

The Dynamic value is boxed in order to avoid bloating the size of Expr.

BoolConstant(bool, Position)

Boolean constant.

IntegerConstant(i64, Position)

Integer constant.

FloatConstant(FloatWrapper<f64>, Position)

Available on non-crate feature no_float only.

Floating-point constant.

CharConstant(char, Position)

Character constant.

StringConstant(ImmutableString, Position)

String constant.

InterpolatedString(ThinVec<Expr>, Position)

An interpolated string.

Array(ThinVec<Expr>, Position)

[ expr, … ]

Map(Box<(SmallVec<[(Ident, Expr); 3]>, BTreeMap<SmartString<LazyCompact>, Dynamic>)>, Position)

#{ name:expr, … }

Unit(Position)

()

Variable(Box<(Option<NonZero<usize>>, ImmutableString, Namespace, u64)>, Option<NonZero<u8>>, Position)

Variable access - (optional long index, variable name, namespace, namespace hash), optional short index, position

The short index is u8 which is used when the index is <= 255, which should be the vast majority of cases (unless there are more than 255 variables defined!). This is to avoid reading a pointer redirection during each variable access.

ThisPtr(Position)

this.

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

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

MethodCall(Box<FnCallExpr>, Position)

xxx . method ( expr , … )

Stmt(Box<StmtBlock>)

{ statement … }

FnCall(Box<FnCallExpr>, Position)

func ( expr , … )

Dot(Box<BinaryExpr>, ASTFlags, Position)

lhs . rhs | lhs ?. rhs

Flags

• NEGATED = ?. (. if unset)
• BREAK = terminate the chain (recurse into the chain if unset)

Index(Box<BinaryExpr>, ASTFlags, Position)

lhs [ rhs ]

Flags

• NEGATED = ?[ … ] ([ … ] if unset)
• BREAK = terminate the chain (recurse into the chain if unset)

And(Box<SmallVec<[Expr; 3]>>, Position)

lhs && rhs

Or(Box<SmallVec<[Expr; 3]>>, Position)

lhs || rhs

Coalesce(Box<SmallVec<[Expr; 3]>>, Position)

lhs ?? rhs

Custom(Box<CustomExpr>, Position)

Available on non-crate feature no_custom_syntax only.

Custom syntax

Implementations

impl Expr

pub fn get_literal_value( &self, global: Option<&GlobalRuntimeState>, ) -> Option<Dynamic>

Get the Dynamic value of a literal constant expression.

Returns None if the expression is not a literal constant.

pub fn from_dynamic(value: Dynamic, pos: Position) -> Expr

Create an Expr from a Dynamic value.

pub const fn options(&self) -> ASTFlags

Get the options of the expression.

pub const fn position(&self) -> Position

Get the position of the expression.

pub fn start_position(&self) -> Position

Get the starting position of the expression. For a binary expression, this will be the left-most LHS instead of the operator.

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

Override the position of the expression.

pub fn is_pure(&self) -> bool

Is the expression pure?

A pure expression has no side effects.

pub const fn is_unit(&self) -> bool

Is the expression the unit () literal?

pub fn is_constant(&self) -> bool

Is the expression a constant?

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

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

pub fn take(&mut self) -> Expr

Return this Expr, replacing it with Expr::Unit.

pub fn walk<'a>( &'a self, path: &mut Vec<ASTNode<'a>>, on_node: &mut (impl FnMut(&[ASTNode<'_>]) -> bool + ?Sized), ) -> 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 duplicate 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<(), Error>

Formats the value using the given formatter.

impl Default for Expr

fn default() -> Expr

Returns the “default value” for a type.

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

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

Converts to this type from the input type.

impl Hash for Expr

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.