Struct Printf 

pub struct Printf {
    pub format: String,
    pub parsed: ParsedFormat,
    /* private fields */
}

Printf-style N→1 formatting node. Variadic: accepts 0..N wire inputs.

Signature: printf(format: String, in_0, in_1, ...) -> (String)

Format string uses Rust-style {} placeholders with optional specifiers: {:05} (zero-pad), {:.2} (precision), {:x} (hex), {:X} (HEX), {:b} (binary), {:o} (octal). Inputs are matched positionally.

Use for constructing complex formatted strings from multiple Polydat wires: printf("user-{:05}-score-{:.1}", id, score) → “user-00042-score-98.6”

All Value types are accepted at eval time regardless of declared port types (the variadic slots advertise PortType::Str but the body dispatches on Value variants). The format specifier determines how each value renders.

SRD-73 follow-up: None propagation through string interpolation. If any REFERENCED input is Value::None, the whole result is Value::None. The body itself doesn’t materialise this — the Polydat kernel’s SRD-74 Rule 1 guard (engines.rs) emits Value::None on every output for any node whose inputs include Value::None and which doesn’t opt into accepts_none_inputs. Printf doesn’t opt in, so the kernel guard fires before this body is invoked at production time.

Rationale: Value::None is the canonical “absent” sentinel. The Polydat Kernel’s lookup / get_constant already treat None-valued outputs as “not present in this scope” and fall through to the parent scope. String interpolation is the surface where that discipline was being silently broken — an unresolved {X} in a source-level string literal compiles to a printf call with the unresolved name’s slot, and when that slot evaluates to None the printf result should likewise be None so the binding doesn’t shadow upstream defaults. The canonical end-to-end coverage for this lives in tests/scope_composition.rs::const_with_unbound_interpolation_*.

Fields

format: String

The format argument, as given at construction.

parsed: ParsedFormat

The parsed value, computed once at construction.

Implementations

impl Printf

pub fn new(format: String, n_wires: usize) -> Self

A printf node with the given constant arguments.

Trait Implementations

impl PolydatNode for Printf

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_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 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_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 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.