Struct PolydatState 

pub struct PolydatState {
    pub core: EngineCore,
    /* private fields */
}

Polydat evaluation engine using precomputed per-input dependent lists.

On set_input(), only nodes that depend on the changed input are dirtied. O(affected_nodes) per input change. This is the default engine for production use.

Fields

core: EngineCore

Shared evaluation core (buffers, clean flags, inputs).

Implementations

impl PolydatState

pub fn set_inputs(&mut self, coords: &[u64])

Set all coordinate inputs at once. Wraps each u64 as Value::U64 and sets them at indices 0..N with per-input change detection.

pub fn set_input(&mut self, idx: usize, value: Value)

Set a single input by index, dirtying only dependent nodes.

Single-register semantics: a cell-bound slot’s only register IS the cell — set_input writes through the cell. A non-cell slot’s register is the local inputs[idx] array. There’s no second snapshot kept in lockstep with the cell; reads always go to whichever is the slot’s register.

Dependents-marking is the dependent-list invalidation strategy carried by PolydatState; it’s the write-side half of the engine’s dirty-tracking. Other engines (RawState, ProvScanState) implement different strategies — see their own set_inputs impls.

pub fn get_input(&self, idx: usize) -> Value

Read the value of an input by index.

Single-register read: cell-bound slots return the cell’s current value; non-cell slots return the local register. One canonical value per slot, no stale snapshot.

pub fn read_input_value(&self, idx: usize) -> Value

Alias for Self::get_input; kept for legacy callers that picked the more explicit name. Both read the cell when one is attached.

pub fn attach_shared_cell(&mut self, idx: usize, cell: SharedCell)

Attach a SharedCell to an input slot.

After this call the cell becomes the slot’s sole register: reads via read_input go through the cell, set_input writes through the cell. The local inputs[idx] array entry for this slot is unused for cell-bound slots — there is no second register kept in lockstep.

Dependents are dirtied because the slot’s effective value just changed from the local default to whatever the cell currently holds.

pub fn shared_cell(&self, idx: usize) -> Option<SharedCell>

Returns the SharedCell attached to an input slot, if any. Used by materialize_wiring_from_outer to share an existing cell with inner kernels.

pub fn reset_inputs_from(&mut self, from_idx: usize)

Reset a range of inputs to their defaults. Used at stanza boundaries to prevent capture leakage across stanzas. from_idx is typically coord_count (skip coordinates, reset only capture inputs).

Cell-bound slots are skipped: the cell is cross-kernel shared state with its own lifecycle (managed by the owning ancestor scope), and a stanza-local reset must not clobber other kernels’ views.

pub fn invalidate_all(&mut self)

Mark every node dirty and leave the inputs as they are: every node reruns at the next pull, as if the cycle had moved. What Kernel::invalidate_all means on every engine; a host that wants the inputs back at their defaults calls Self::reset_inputs_from as well.

pub fn pull(&mut self, program: &PolydatProgram, output_name: &str) -> &Value

Pull a named output variate from the program.

pub fn seed_node_buffer( &mut self, node_idx: usize, port_idx: usize, value: Value, )

Pre-populate a node’s output buffer slot and mark it clean, suppressing on-demand evaluation. Used by the scope-init pass (SRD 11 §“Init Binding Contract” Plan B) to seed per-fiber states with init binding values that the activation kernel already evaluated, so each fiber doesn’t re-fire the eval at first pull.

pub fn node_buffer(&self, node_idx: usize, port_idx: usize) -> Option<&Value>

Read a node’s output buffer slot. Used by the scope-init pass to extract a pre-pulled init binding value from one state and seed it into another.

pub fn pull_by_index( &mut self, program: &PolydatProgram, output_idx: usize, ) -> &Value

Pull an output by index (declaration order). Only evaluates the computation cone for this specific output.

pub fn pull_all<'a>(&'a mut self, program: &PolydatProgram) -> Vec<&'a Value>

Pull all outputs in declaration order.

pub fn accessor(program: &PolydatProgram, names: &[&str]) -> OutputAccessor

Create a memoized accessor for a named subset of outputs. Resolves names to indices once; subsequent access uses indices only.