Struct TileProgram 

pub struct TileProgram {
    pub spec: TileSpec,
    pub bodies: Vec<Arc<BodySource>>,
    pub children: Vec<Arc<PolydatProgram>>,
    /* private fields */
}

The runtime form: the spec, compiled body programs, and parsed streams.

Fields

spec: TileSpec

The serialized skeleton.

bodies: Vec<Arc<BodySource>>

Each projection body, as the one carrier a for body uses: its statements, the settings it compiles under, and its program per engine, built on first use, so construction compiles no body for an engine that never renders it.

children: Vec<Arc<PolydatProgram>>

The body programs for the interpreter, which construction needs: the canonical kernels are built over them, and memoisation runs against those.

Implementations

impl TileProgram

pub fn from_parts( spec: TileSpec, bodies: Vec<Arc<BodySource>>, ) -> Result<Self, String>

A program from a skeleton and the bodies its projections run.

The compiler’s path: it lowered the bodies, so it hands them over as they are. Each body carries the settings the parent compiled under, and its program per engine is built when a render on that engine first asks for it.

pub fn from_json(json: &str) -> Self

A program from a serialized skeleton, whose projection bodies are rebuilt from the source text it carries under the default settings.

The route for a skeleton that reaches the runtime as text — a host that stored one, a test that wrote one. The compiler’s own path is Self::from_parts, which hands the bodies over rather than describing them. A standalone skeleton is a tree of its own: its bodies share a fresh compile ledger and resource scope. Self::from_json_for loads one for a kernel’s tree.

pub fn from_json_for(json: &str, kernel: &dyn Kernel) -> Self

A program from a serialized skeleton, loaded for kernel, the kernel that renders it: its projection bodies compile in the kernel’s tree as an inline tile’s bodies do, recording their programs on the kernel’s CompileLedger and reaching the host resources through the kernel’s ResourceScope (polytile.md §7.1).

pub fn has_projections(&self) -> bool

True when any op re-runs a projection body.

pub fn render(&self, inputs: &[Value], bodies: &mut BodyKernels) -> String

Render with the node’s wire inputs, the hole values, on the interpreter, over bodies, the rendering state’s own kernels for the projection bodies.

pub fn render_into<W: Write>( &self, inputs: &[ValueRef<'_>], engine: Engine, bodies: &mut BodyKernels, out: &mut W, )

Render into any text sink from borrowed views of the hole values: a String at P1, a step’s own scratch in a compiled closure. Every hole is encoded here, from the view straight into the sink, and a projection’s body runs on engine, the engine of the kernel rendering, in a kernel the rendering state owns (bodies) and reuses across renders.

Trait Implementations

impl Debug for TileProgram

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

Formats the value using the given formatter.