Enum ExprKind 

pub enum ExprKind {
    Number(String),
    TypedLiteral {
        value: Box<Expr>,
        ty: Type,
    },
    Bool(bool),
    Text(String),
    Unit,
    Name(String),
    List(Vec<Expr>),
    TensorLiteral {
        values: Vec<Expr>,
        dtype: Type,
    },
    Match {
        value: Box<Expr>,
        arms: Vec<MatchArm>,
    },
    Propagate(Box<Expr>),
    Assign {
        target: Box<Expr>,
        value: Box<Expr>,
    },
    Record {
        class: String,
        fields: BTreeMap<String, Expr>,
    },
    Unary {
        op: String,
        value: Box<Expr>,
    },
    Binary {
        op: String,
        left: Box<Expr>,
        right: Box<Expr>,
    },
    Call {
        callee: Box<Expr>,
        arguments: Vec<Expr>,
    },
    TypedFunction {
        name: String,
        ty: Type,
    },
    TypedCall {
        name: String,
        ty: Type,
        arguments: Vec<Expr>,
    },
    TypedMethod {
        object: Box<Expr>,
        method: String,
        ty: Type,
    },
    Field {
        object: Box<Expr>,
        field: String,
    },
    Index {
        object: Box<Expr>,
        indices: Vec<IndexExpr>,
    },
}

Expression syntax before runtime value and effect checks.

Variants

Number(String)

A numeric literal’s exact source spelling; execution parses and validates it.

TypedLiteral

A numeric literal explicitly interpreted at a scalar dtype.

Fields

value: Box<Expr>

Unsuffixed numeric literal, including a unary negative sign when present.

ty: Type

Required numeric dtype.

Bool(bool)

A Boolean literal.

Text(String)

A UTF-8 string literal.

Unit

The empty value ().

Name(String)

Read a lexical binding or module global.

List(Vec<Expr>)

An ordered collection or homogeneous list type.

TensorLiteral

A nested list literal with an explicit scalar dtype, packed by the checker.

Fields

values: Vec<Expr>

Outer list values, retaining nested ExprKind::List structure.

dtype: Type

Declared scalar dtype.

Match

Select an expression result by structural patterns.

Fields

value: Box<Expr>

Scrutinee evaluated once before trying arms.

arms: Vec<MatchArm>

Arms considered in source order.

Propagate(Box<Expr>)

Propagate a result-like failure according to the enclosing function contract.

Assign

An explicit parenthesized assignment expression whose checked result can carry recoverable data-operation failure.

Fields

target: Box<Expr>

Writable location, including an indexed tensor or list access.

value: Box<Expr>

Value assigned after the target location has been resolved.

Record

Construct a nominal class value.

Fields

class: String

Nominal class name, optionally qualified by an imported module.

fields: BTreeMap<String, Expr>

Fields keyed or ordered according to the containing syntax node.

Unary

Apply logical negation or numeric negation.

Fields

op: String

Operator spelling, whose operand contract is checked by the interpreter.

value: Box<Expr>

Operand, initializer, or assigned expression.

Binary

Apply arithmetic, comparison, or short-circuit Boolean operations.

Fields

op: String

Operator spelling, whose operand contract is checked by the interpreter.

left: Box<Expr>

Left operand, evaluated first.

right: Box<Expr>

Right operand; logical operators short-circuit its evaluation.

Call

Call a reusable function, constructor, or method.

Fields

callee: Box<Expr>

Named function, constructor, or receiver method.

arguments: Vec<Expr>

Argument expressions in left-to-right evaluation order.

TypedFunction

A concrete ECS builtin function value such as get[Transform].

Fields

name: String

Intrinsic name: get, has, query, or bind.

ty: Type

Statically resolved component or query type.

TypedCall

Call a typed ECS intrinsic such as get[Transform](entity).

Fields

name: String

Intrinsic name: get, has, or query.

ty: Type

Statically resolved component or query type.

arguments: Vec<Expr>

Argument expressions in left-to-right evaluation order.

TypedMethod

A typed method target such as matrix.convert[f32], callable through the ordinary ExprKind::Call form.

Fields

object: Box<Expr>

Receiver evaluated before method invocation.

method: String

Method name.

ty: Type

Statically supplied type argument.

Field

Read a class field.

Fields

object: Box<Expr>

Receiver expression.

field: String

Selected class field name.

Index

Index or slice a collection or tensor.

Fields

object: Box<Expr>

Receiver expression.

indices: Vec<IndexExpr>

One or more NumPy-style index selectors.

Trait Implementations

impl Clone for ExprKind

fn clone(&self) -> ExprKind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ExprKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExprKind

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ExprKind

fn eq(&self, other: &ExprKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ExprKind

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ExprKind