value

type Apply ¶

type Apply struct {
	Fn  Value
	Arg Value
	Pos source.SourcePos
}

An Apply is a runtime-synthesized application Fn Arg. The compiled bytecode never builds one — it pushes arguments and enters the head (the spine-less model). The only place an Apply is created is reducing a composition, which must turn (First ∘ Second) x into the application First (Second x). Pos locates a "cannot apply" failure.

type Builtin ¶

type Builtin struct {
	Prim  PrimOp
	Arity int
	Args  []Value
	Name  string
}

A Builtin is a primitive operation as a first-class value. It carries the operation, its arity, and the arguments gathered so far; applying it appends one argument, and when the count reaches Arity the machine runs the operation. This single representation is both the saturated and the partially-applied form: partial application is just a Builtin with fewer Args than Arity (see prims.go).

type Closure ¶

type Closure struct {
	Code    PC
	Env     []Value
	Frame   int
	NoMatch source.SourcePos
}

A Closure is a lambda (one or more pattern cases) paired with the minimal set of free variables it captured. Frame is the largest of its cases' frame sizes, allocated once per application. NoMatch is the source span of the whole pattern set, used to locate a "no pattern matched" error.

type Composition ¶

type Composition struct {
	First  Value
	Second Value
}

A Composition is an unreduced function composition. Applying (First ∘ Second) to x reduces to First (Second x); see the CompositionTag case of reduce.

type Cons ¶

type Cons struct {
	Head Value
	Tail Value
}

A Cons is a head/tail pair. Thunky draws no distinction between a 2-tuple and a list cons cell (see LANGUAGE.md §11), so every arity-2 tuple — list literals, string code points, the stdin stream, a bare [a, b] pair — is a Cons. This packs the pair into one allocation and lets list code destructure cons cells directly.

type ListEnding ¶

type ListEnding int

const (
	NotAList ListEnding = iota
	ProperList
	Truncated
	Cyclic
)

type PC ¶

type PC = int32

PC is a program counter: an index into the compiled instruction array. It lives here because Thunk and Closure store entry points; the backend re-exports it.

const NoCode PC = -1

type PrimOp ¶

type PrimOp uint8

const (
	PrimAdd PrimOp = iota
	PrimSub
	PrimMul
	PrimDiv
	PrimFdiv
	PrimMod
	PrimFmod
	PrimPow
	PrimSqrt
	PrimEq
	PrimLt
	PrimLte
	PrimGte
	PrimGt
	PrimNeq

	PrimEqual
	PrimEval
	PrimPeek
	PrimShow
	PrimWrite
	PrimBwrite
	PrimString
	PrimHash

	PrimSeq // seq a b: force a to WHNF, return b unforced (the only non-numeric,

)

type Tag ¶

type Tag uint8

const (
	NumberTag      Tag = iota // Num holds the value; Ref is nil
	ConsTag                   // Ref = *Cons
	TupleTag                  // Ref = *Tuple   (arity 0, 1, 3, 4, …; never 2)
	ClosureTag                // Ref = *Closure
	BuiltinTag                // Ref = *Builtin
	CompositionTag            // Ref = *Composition
	ApplyTag                  // Ref = *Apply   (a runtime-synthesized application)
	ThunkTag                  // Ref = *Thunk   (not yet in weak head normal form)
)

type Thunk ¶

type Thunk struct {
	Forced   bool
	Value    Value
	Name     string
	Code     PC
	Locals   []Value
	Upvalues []Value
	Read     func() Value
}

A Thunk is a deferred computation that memoises its result. It comes in three forms, distinguished without a tag field:

• Read != nil — a stdin stream cell; forcing it calls Read to obtain its weak head normal form (a cons cell or the empty list) and reads one input item.
• Code == NoCode — a graph indirection (a pattern binding); forcing it reduces the value already in Value and memoises the result. This keeps the bound name on the trace/show path without the name's owner having to re-evaluate.
• Code >= 0 — a compiled thunk; forcing it runs the body at Code over the captured frames (whole-frame capture, see below).

Code thunks capture the entire enclosing activation (Locals and Upvalues) by reference and address it with the enclosing slot numbers — no renumbering, and mutual recursion in a let group resolves because every binding thunk shares the frame, which is fully populated before any binding is forced.

Every thunk memoises (call-by-need): the first force runs the computation and writes the weak-head-normal-form result back into Value (setting Forced), so it is never recomputed. This is why re-forcing a thunk that embeds an output builtin (peek/show/write/bwrite) does not repeat the effect — the effect runs exactly once, when the thunk is first forced.

type Tuple ¶

type Tuple struct {
	Fields []Value
}

A Tuple is an ordered sequence of any arity except 2 (arity 0, 1, 3, 4, …); the empty tuple is also the empty list. Arity-2 tuples are Cons cells instead.

type Value ¶

type Value struct {
	Tag Tag
	Num float64
	Ref any
}

A Value is one runtime value, passed around by value (not by pointer). It is a small tagged union: a Number lives inline in Num, while every compound or heap-resident value keeps a pointer in Ref. This is the deliberate alternative to a Go interface for the runtime representation:

• A number never allocates. A float64 boxed into an interface{} heap-allocates on every arithmetic result; Value{Tag: NumberTag, Num: x} does not. Numeric programs allocate the most, so this is where the representation earns its keep.
• Ref holds a *pointer* (to Cons, Tuple, …). A pointer stored in an interface does NOT allocate in Go, so compound values pay only their own heap cost, never an extra box.
• The Tag makes the variant explicit and cheap to switch on, instead of a type switch on an interface's dynamic type.

func ApplyValue(fn, arg Value, pos source.SourcePos) Value

func BuiltinValue(b *Builtin) Value

func ClosureValue(c *Closure) Value

func ConsValue(h, t Value) Value

func EvalPrim(op PrimOp, args []Value) Value

func EvalPrim1(op PrimOp, a float64) Value

func EvalPrim2(op PrimOp, a, b float64) Value

func EvalStructuralBuiltin(op PrimOp, args []Value) Value

func FoldStringValue(s string) Value

func FullNormalForm(value Value, seen map[*Thunk]bool) Value

func NumberValue(n float64) Value

func StdinBytes() Value

func StdinCodePoints() Value

func ThunkValue(t *Thunk) Value

func TupleValue(t *Tuple) Value

func (v Value) Apply() *Apply

func (v Value) Builtin() *Builtin

func (v Value) Closure() *Closure

func (v Value) Composition() *Composition

func (v Value) Cons() *Cons

func (v Value) IsFunction() bool

func (v Value) Thunk() *Thunk

func (v Value) Tuple() *Tuple