Enum Term 

pub enum Term {
    Int(i64),
    Fix(i64),
    Bool(bool),
    Text(String),
    Var(u32),
    Let(Box<Term>, Box<Term>),
    If(Box<Term>, Box<Term>, Box<Term>),
    Prim(PrimOp, Vec<Term>),
    Rec(BTreeMap<String, Term>),
    Get(Box<Term>, String),
    ListNew(Vec<Term>),
    Call(WeftHash, Vec<Term>),
    Effect(EffectKind, BTreeMap<String, Term>),
    Map {
        cap: u32,
        list: Box<Term>,
        body: Box<Term>,
    },
    Fold {
        cap: u32,
        list: Box<Term>,
        init: Box<Term>,
        body: Box<Term>,
    },
    Iota {
        cap: u32,
        count: Box<Term>,
    },
}

The term graph. Variables are de Bruijn indices (0 = innermost binder); a definition’s parameters are the outermost binders, in order.

Variants

Int(i64)

Fix(i64)

Fixed-point literal (raw millionths — Term::Fix(1_500_000) is 1.5).

Bool(bool)

Text(String)

Var(u32)

de Bruijn index into the binder stack.

Let(Box<Term>, Box<Term>)

Bind the first term’s value; evaluate the second with it as index 0.

If(Box<Term>, Box<Term>, Box<Term>)

Prim(PrimOp, Vec<Term>)

Rec(BTreeMap<String, Term>)

Record construction; field order is canonical (sorted) via BTreeMap.

Get(Box<Term>, String)

Field projection.

ListNew(Vec<Term>)

Call(WeftHash, Vec<Term>)

Call another definition by hash — the only kind of call.

Effect(EffectKind, BTreeMap<String, Term>)

Construct an effect request (an [Action] value). Pure.

Map

Bounded map: evaluate body (element = Var 0) for each of at most cap elements of list — elements beyond the cap are dropped. The cap is what keeps the fuel bound static: totality never bends.

Fields

cap: u32

list: Box<Term>

body: Box<Term>

Fold

Bounded fold: thread an accumulator through at most cap elements (body sees acc = Var 1, element = Var 0).

Fields

cap: u32

list: Box<Term>

init: Box<Term>

body: Box<Term>

Iota

The list 0..min(count, cap) — the generator’s seed. cap keeps the fuel bound static; with Map/Fold it makes rings, grids, and spirals.

Fields

cap: u32

count: Box<Term>

Trait Implementations

impl Clone for Term

fn clone(&self) -> Term

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Term

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Term

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Term

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Term

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 Term