Module render 

Re-exports

pub use until::Until;

Modules

until

Structs

Block

Built

What one change did anew, not what it carried over.

Counts

Handle

Never

Range

Where a target is read, in samples from t = 0. Unstated, the root’s own support.

Render

RenderConfig

Session

Renders made in turn: each types only what changed since the last, and what reads it.

Stream

A target rendered block by block off one table, reading @notes, the sum of the terms added. A change builds only what it changed or newly reads; the rest stays as it stood.

StreamConfig

Enums

Change

An edit, each with the graph that reaches it and all the stream plays.

Changed

A replace or remove answers whether the stream still held its handle.

Out

Whether a render hands back its root’s samples; dropped, with no reading asked, it holds none past each block.

Placed

Where a term’s sample 0 sits: the stream’s own, or the sample its add lands at.

Constants

LATEST

The lookups, and the names started silent, a stream keeps of all it made.

NOTES

The node a stream defines as the sum of its terms, for its expression to read as @notes.

STREAMED

Traits

Abandon

Whether a render’s caller let it go, asked between blocks.

Functions

answer

A closed form answers off its spectral sum and a buffer off its samples; its own Ty decides which, never a flag on the observation.

answer_buffer

One reading off a buffer nothing rendered — an external file, say — under the profile the caller names. Every representation needing the graph behind it refuses here.

change

build’s change, the stream held only while each try runs, between two blocks: an exact stream pulled once its edit is done plays it where issued. build runs again whenever the stream changed under it.

ends

The sample each of roots read bare would end at, None where its support, pruning included, never ends and such a render refuses for it. Typed together, and no sample.

fetch

What the next second of stream reads off memory, as far as one fetch reaches; a block reading samples not ready computes them, or, live, starts them silent.

plan

The range and every value a render of target would compute, and no sample.

render

render_over memory alone. Nothing is materialized that no reading asked for.

render_in

target over tier, from the root down: every node is named by what it computes, typed anew only where session typed it otherwise, and a node memory answers stands as its samples, nothing under it planned or computed; with out dropped and no reading, a root it answers ends the render unread. Abandoned, it stops before its next block.

render_over

target over tier, from the root down, in a session of its own.

sketch_atom

One atom as the six factors it is present in, which is what atoms answers with.