Enum quad_compat_rhai::Expr

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

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

Variants

DynamicConstant(Box<Dynamic>, Position)

Tuple Fields

0: Box<Dynamic>

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

BoolConstant(bool, Position)

Tuple Fields

0: bool

1: Position

Boolean constant.

IntegerConstant(INT, Position)

Tuple Fields

0: INT

1: Position

Integer constant.

FloatConstant(FloatWrapper<FLOAT>, Position)

Tuple Fields

0: FloatWrapper<FLOAT>

1: Position

Floating-point constant.

Not available under no_float.

CharConstant(char, Position)

Tuple Fields

0: char

1: Position

Character constant.

StringConstant(ImmutableString, Position)

Tuple Fields

0: ImmutableString

1: Position

String constant.

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

Tuple Fields

0: Box<StaticVec<Expr>>

1: Position

An interpolated string.

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

Tuple Fields

0: Box<StaticVec<Expr>>

1: Position

[ expr, … ]

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

Tuple Fields

0: Box<(StaticVec<(Ident, Expr)>, BTreeMap<Identifier, Dynamic>)>

1: Position

#{ name:expr, … }

Unit(Position)

Tuple Fields

0: Position

()

Variable(Option<NonZeroU8>, Position, Box<(Option<NonZeroUsize>, Option<(NamespaceRef, u64)>, Identifier)>)

Tuple Fields

0: Option<NonZeroU8>

1: Position

2: Box<(Option<NonZeroUsize>, Option<(NamespaceRef, u64)>, Identifier)>

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

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.

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

Tuple Fields

0: Box<((Identifier, u64), (Identifier, u64), (ImmutableString, Position))>

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

Stack(usize, Position)

Tuple Fields

0: usize

1: Position

Stack slot for function calls. See FnCallExpr for more details.

This variant does not map to any language structure. It is used in function calls with constant arguments where the usize number indexes into an array containing a list of constant arguments for the function call.

Stmt(Box<StmtBlock>)

Tuple Fields

0: Box<StmtBlock>

{ statement … }

FnCall(Box<FnCallExpr>, Position)

Tuple Fields

0: Box<FnCallExpr>

1: Position

func ( expr , … )

Dot(Box<BinaryExpr>, bool, Position)

Tuple Fields

0: Box<BinaryExpr>

1: bool

2: Position

lhs . rhs - bool variable is a dummy

Index(Box<BinaryExpr>, bool, Position)

Tuple Fields

0: Box<BinaryExpr>

1: bool

2: Position

expr [ expr ] - boolean indicates whether the dotting/indexing chain stops

And(Box<BinaryExpr>, Position)

Tuple Fields

0: Box<BinaryExpr>

1: Position

lhs && rhs

Or(Box<BinaryExpr>, Position)

Tuple Fields

0: Box<BinaryExpr>

1: Position

lhs || rhs

Custom(Box<CustomExpr>, Position)

Tuple Fields

0: Box<CustomExpr>

1: Position

Custom syntax

Implementations

impl Expr

pub fn get_literal_value(&self) -> 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) -> Self

Create an Expr from a Dynamic value.

pub const 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 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 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 AsRef<Expr> for Expression<'_>

fn as_ref(&self) -> &Expr

Performs the conversion.

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

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

Feeds a slice of this type into the given Hasher.