Enum Value 

pub enum Value {
    Enum(Box<EnumValue>),
    Number(f64),
    Scalar(Scalar),
    Tensor(Box<Tensor>),
    Bin(Bin),
    Bool(bool),
    Text(Str),
    List(Vec<Value>),
    Record(RecordValue),
    Function(Box<FunctionValue>),
    ComponentReference(ComponentReference),
    Entity(u64),
    Unit,
}

Stable JSON representation shared by native and WebAssembly hosts.

Variants

Enum(Box<EnumValue>)

A nominal algebraic case or a built-in Res/Opt value with checked payloads.

Matching inspects the case and binds payload values. There is no null value or exception syntax; recoverable operation failures are ordinary Err values.

Number(f64)

A finite IEEE 754 binary64 scalar with canonical language type f64.

Number remains a source alias for f64 and this host representation remains compatible with native spatial interfaces. Literals without numeric context default to f64. Exact integer widths and f16/f32/f128 use Scalar instead. Numeric variables never implicitly change dtype; use .convert[T]() for an explicit conversion, which rejects overflow and loss of information.

Scalar(Scalar)

An exact width-specific numeric scalar.

Supported widths are u8 through u128, i8 through i128, f16, f32, and f128. Integer arithmetic checks overflow and floating arithmetic rounds once to the declared IEEE format. Serialized decimal strings preserve values across JSON hosts without passing wide integers through binary64.

Tensor(Box<Tensor>)

An immutable packed Tensor[T] with shared storage and checked shape/stride views.

A tensor stores one numeric dtype and a runtime shape. Comma-separated indices select scalar elements; slices preserve tensors and share their allocation. Arithmetic broadcasts trailing dimensions; @ multiplies matrices and batches. Arithmetic and indexing return Res; get returns Opt for a scalar lookup. Dtypes must match, with contextual typing reserved for literal operands.

Bin(Bin)

Immutable bytes without an implied text encoding.

Cloning shares a packed Arc allocation. bytes constructs Bin from List[u8], Str.utf8 encodes text, and Bin.decode validates UTF-8 with a Res result. Indexing returns Res[u8, DataError]; slicing produces Res[Bin, DataError]. Concatenation creates independent data and respects byte limits.

Bool(bool)

A Boolean value used by conditions and short-circuit expressions.

Bool stores a Rust bool and has exactly two values: true and false. if and while require Bool; numeric zero and empty collections do not act as false. and and or evaluate their right side only when needed.

Text(Str)

Immutable UTF-8 text with canonical language type Str (String is an alias).

Clones share an Arc allocation. Concatenation creates a new value without implicit conversion. len, indexing, and slices count Unicode scalar values, while allocation limits count UTF-8 bytes. utf8 encodes to Bin and decode validates Bin as UTF-8. Text is the separate visible scene component.

List(Vec<Value>)

An ordered owned collection whose elements share one language type.

List[T] stores Rust Vec<Value> data. The compiler retains T and the runtime checks elements at typed boundaries. An empty literal needs a contextual element type, such as let values: List[f64] = [];.

Indexing starts at zero and rejects out-of-range indices. Assignment copies a list value; .append(value) returns a new list. .get(index) returns Opt[T], while indexing returns Res[T, DataError]. Collection length and nested values remain subject to the embedding host’s Limits.

Record(RecordValue)

A nominal type instance with checked fields.

A RecordValue owns its field map. Constructing a type creates data; spawn attaches it to an ECS entity. Prelude types use this same representation as user types, rather than separate Rust struct aliases.

Function(Box<FunctionValue>)

A statically typed callable with inspectable identity.

FunctionValue stores a checked signature and target identity, not executable code or a raw pointer. Language and native function values use the same argument and result validation. Mutating component methods use bind.

ComponentReference(ComponentReference)

A typed entity/component identity used to capture live component methods.

ComponentReference[T] pairs a Rust entity ID with a canonical concrete type name. bind[T](entity) validates that the component exists; method calls resolve it again and commit accepted receiver changes transactionally.

This is an interpreter handle, not a Rust borrow or raw memory reference. Access component data with get and set; invoke methods through the reference. Invoking a reference after its entity disappears is an error.

Entity(u64)

An opaque ECS identity created by spawn.

Entity stores a Rust u64 handle. IDs are allocated in creation order and cannot be constructed from a Number in the language. Copying a handle keeps the same identity; it does not duplicate the entity or its components.

Use get, set, has and bind with a concrete component type. A handle can outlive its entity, but subsequent access to a removed entity is rejected.

Unit

The single empty value returned by procedures.

Unit is represented by the payload-free Rust Value::Unit variant and spelled () in the language. A function returning Unit may end without a value or use ret;. Unit is not null, an absent field, or an optional value.

Implementations

impl Value

pub fn algebraic(value: EnumValue) -> Self

Construct an algebraic value for a host boundary, where its type and payload are validated.

pub fn record( class: impl Into<String>, fields: impl IntoIterator<Item = (String, Value)>, ) -> Self

Assemble a record for a host input. Machine entry points validate its declared fields.

pub fn number(&self) -> Option<f64>

Read a numeric value without coercion.

pub fn field(&self, key: &str) -> Option<&Value>

Borrow a field of a type instance, if present.

pub fn type_name(&self) -> &str

Return the nominal language type name; Str is distinct from type Text.

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Value

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Value

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Value

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

Formats the value using the given formatter.

impl PartialEq for Value

fn eq(&self, other: &Value) -> 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 Value

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 Value