Enum Type 

pub enum Type {
    Number,
    Text,
    Bool,
    Any,
    Optional(Box<Type>),
    List(Box<Type>),
    Map(Box<Type>, Box<Type>),
    Result(Box<Type>, Box<Type>),
    Sum(Vec<String>),
    Fn(Vec<Type>, Box<Type>),
    Named(String),
    U32,
    U64,
    I64,
}

Types in idea9 — single-char base types, composable

Variants

Number

Text

Bool

Any

Optional(Box<Type>)

List(Box<Type>)

Map(Box<Type>, Box<Type>)

Result(Box<Type>, Box<Type>)

Sum(Vec<String>)

Fn(Vec<Type>, Box<Type>)

Named(String)

U32

32-bit unsigned integer type. Stored as f64 in the tree-walker engine. Precision is exact for integers ≤ 2^32 (≤ 4 294 967 295).

U64

64-bit unsigned integer type. Stored as f64 in the tree-walker engine. PRECISION LIMIT: f64 has 53 mantissa bits, so values > 2^53 lose precision.

I64

64-bit signed integer type. Stored as f64 in the tree-walker engine. PRECISION LIMIT: f64 has 53 mantissa bits, so values outside ±2^53 lose precision.

Implementations

impl Type

Cycle-capability classifier for runtime values of a given static type.

Background: ilo’s runtime is reference-counted (Arc in the tree interpreter, custom RC on HeapObj in the VM). Pure RC cannot reclaim reference cycles (A -> B -> A). Most RC languages pair RC with a cycle collector to handle this. ilo deliberately does NOT — the surface language is structurally cycle-free:

• Records are immutable after construction. with allocates a fresh record; there is no field-assignment expression. Fields are bound from already-evaluated values, so a field cannot refer forward to the record being built.
• Lists and maps are persistent. Mutation goes through copy-on-share (Arc::make_mut, fresh HeapObj allocation). You cannot install a reference back to a holder you no longer have a write handle to.
• Closures capture by value.
• Numbers, booleans, text, sums-of-strings, nil are inline / immutable.

This classifier exists as a foundation. It defines the invariant explicitly and gives us a regression surface if a future language change quietly introduces a cycle-forming construct. It is also the hook a future cycle collector would consult to prune immutable types.

Default policy: when in doubt, return true (cycle-capable). It is always sound to mark a type cycle-capable; the cost is unnecessary scanning. The unsound case is the reverse: marking a cycle-capable type clean would let a real cycle leak forever.

pub fn can_form_cycle<F>(&self, resolve_record: &F) -> bool

where F: Fn(&str) -> Option<Vec<Type>>,

Returns true if a runtime value of this type could possibly participate in a reference cycle under ilo’s current memory model.

resolve_record resolves a record type name to its field types. Pass &|_| None to treat all Named references conservatively (cycle-capable).

Trait Implementations

impl Clone for Type

fn clone(&self) -> Type

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Type

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Type

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Type

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

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 Type