Struct SetOrGet 

pub struct SetOrGet { /* private fields */ }

“Set-or-get” memoizer: returns current if non-zero, otherwise returns fallback.

Signature: set_or_get(current: u64, fallback: u64) -> (u64)

Functionally if current == 0 { fallback } else { current } — a simple conditional. The name reflects its intended use alongside SRD-13f cross-scope shared wires:

  shared query_passes := set_or_get(
      query_passes,
      multiples_at_least(min_cycles, base),
  )

First phase to evaluate this: query_passes reads 0 (the unset sentinel), set_or_get returns the computed fallback, the shared := broadcast writes the value to the parent scope’s SharedCell. Every subsequent phase reads the already-set value and the fallback computation is effectively a no-op (it still evaluates, but its result is discarded). The write-back is idempotent — writing the already-cached value back doesn’t change anything.

Concurrency: first-writer-wins is provided by the SharedCell mutex, not by this node. The node itself is pure — given the same inputs it returns the same output. Concurrent phases evaluating it simultaneously will compute the same fallback and race on the cell write; whichever writes last wins, but they’re writing the same value anyway.

JIT level: P3 (single compare + select).

Implementations

impl SetOrGet

pub fn new() -> Self

A set_or_get node with the given constant arguments.

Trait Implementations

impl Default for SetOrGet

fn default() -> Self

Returns the “default value” for a type.

impl PolydatNode for SetOrGet

fn meta(&self) -> &NodeMeta

Return this node’s metadata (port names and types).

fn eval(&self, inputs: &[Value], outputs: &mut [Value])

Evaluate the node: read from inputs, write to outputs.

fn compiled_u64(&self) -> Option<CompiledU64Op>

Return a compiled u64-only evaluation closure, if this node operates entirely in u64 space.

fn jit_constants(&self) -> Vec<u64>

Return assembly-time constants for JIT compilation.

fn scratch_layout(&self) -> Vec<ScratchElem>

The scratch entries a state owns for this node’s evaluation (axiom S3), one per entry in the order the node expects them in Self::eval_in. Empty for a node that evaluates over Values alone, which is every node but a native cone.

fn eval_in( &self, scratch: &mut [ScratchBuf], inputs: &[Value], outputs: &mut [Value], )

Self::eval with the node’s scratch, which the evaluating state owns and hands in: storage belongs to the state, never to the node, which is shared by every state of the program.

fn commutativity(&self) -> Commutativity

Declare which inputs are interchangeable for this node.

fn accepts_none_inputs(&self) -> bool

True iff this node should receive Value::None inputs directly rather than have the kernel propagate None through it. Default: false — most nodes follow SRD-74 Rule 1 (None in → None out, no eval invocation).

fn compiled_slot(&self, _wire_types: &[PortType]) -> Option<CompiledSlotKit>

Return a slot-compiled closure for nodes with typed-slice ports (§8.4 layer 3): slice inputs read (ptr, len) slot pairs; vector outputs write into kernel-owned scratch. Checked by the compiled-kernel builders AFTER Self::compiled_u64 — pure-scalar nodes never need it. Default None: the node stays on typed eval.

fn purity(&self) -> Purity

Declare this node’s purity status per the runtime_model.md’s D2 axiom. Default: Purity::Pure. Override to declare an observable side channel (Purity::SideChannel) or eval-call-spanning state (Purity::Nondeterministic).

fn simd_variant(&self) -> Option<SimdVariant>

Explicit SIMD-native implementation of this scalar node, if one has been registered with a semantic contract.

fn fusion_subgraph(&self) -> Option<FusionSubgraph<'_>>

A synthetic fusion node’s view of the subgraph it stands in for (SRD-105 cone extraction). Program-identity hashing (PolydatProgram::canonical_hash) walks THROUGH fusion nodes into this subgraph, so identity is invariant to the engine mix: jit=off and jit=auto compiles of the same source hash identically, and resume-skip matching survives mode changes. Default None: ordinary nodes hash as themselves.