Enum HeapObject 

pub enum HeapObject {
    Int(i64),
    Array(Vec<Value>),
    Tuple(Vec<Value>),
    Str(String),
    Struct {
        type_name: String,
        fields: Vec<Value>,
    },
    EnumVariant {
        type_name: String,
        variant: String,
        payload: Vec<Value>,
    },
    FileHandle {
        path: String,
        content: String,
        closed: bool,
    },
}

a value living on the VM heap, reached through a TAG_PTR Value.

every variant a MAKE_* opcode builds, plus HeapObject::Int – because i64 is uniformly heap-boxed (the codec in value.rs has no integer tag). a HeapObject::FileHandle that is freed while still open is a resource leak the VM logs.

derives Clone, PartialEq but NOT Debug – a variant carries Value, and Value’s locked derive list (the NaN-box newtype) omits Debug. tests compare HeapObjects with == rather than assert_eq! for that reason.

Variants

Int(i64)

a 64-bit signed integer. i64 has no NaN-box tag, so every integer runtime value is one of these, reached through a pointer.

Array(Vec<Value>)

a dynamic array of values, built by MAKE_ARRAY. push / pop mutate it; INDEX reads an element; LEN reports the element count.

Tuple(Vec<Value>)

a fixed-shape tuple of values, built by MAKE_TUPLE. distinct from HeapObject::Array so the stdlib’s type_of (plan 05-05) can render a tuple’s structural type (i64, str) rather than an array type. INDEX reads an element exactly as it does for an array.

Str(String)

an owned string, built by a CONST of a ConstValue::Str or by CONCAT_N / TO_STR.

Struct

a struct instance: the declared type name (from Program.structs) plus the field values in declaration order.

Fields

type_name: String

the declared struct name, e.g. "Point" – what type_of returns.

fields: Vec<Value>

the field values, in the struct’s declaration order.

EnumVariant

an enum-variant instance: the enum name, the variant name, and the variant’s payload values (empty for a payload-less variant).

Fields

type_name: String

the enum’s declared name, e.g. "Shape".

variant: String

the variant’s name, e.g. "Circle".

payload: Vec<Value>

the variant’s payload values, in declaration order.

FileHandle

a mock file handle – open builds one, close marks it closed. the VM does no real file I/O (it runs in a WASM sandbox); the handle backs the effect system and defer close(f) demonstrations. a handle freed while still open is a leak.

Fields

path: String

the path passed to open. purely informational in the mock.

content: String

the mock file content; read_all returns this.

closed: bool

true once close has run on this handle.

Trait Implementations

impl Clone for HeapObject

fn clone(&self) -> HeapObject

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl PartialEq for HeapObject

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