Struct ScopeKernel 

pub struct ScopeKernel { /* private fields */ }

A scope kernel and the interpreter program it stands for.

Implementations

impl ScopeKernel

pub fn root( interpreter: PolydatKernel, image: Option<Arc<dyn KernelProgram>>, ) -> Self

A root scope compiled from source: interpreter is the compiled kernel, and image the fiber engine’s program for the same source and options, when it can stand in for interpreter’s program (crate::fiber_engine::source_image).

pub fn compile(source: &str) -> Result<Self, String>

A root scope compiled from source with default options (crate::bindings::compile_scope_kernel).

pub fn build_under( parent: &dyn Kernel, matter: SourceMatter, ) -> Result<Self, String>

A child scope built from source matter under parent — the any-engine form of build_subscope (native_scope_trees.md §5): the matter finalizes to a module, which is instantiated under parent. Strict mode refuses a const that silently fell through to an outer value, as build_subscope does.

pub fn synthesize_under( parent: &ScopeKernel, matter: SourceMatter, ) -> Result<Self, String>

Self::build_under a parent scope, then write each of the parent’s input values into the child’s input of the same name — how every synthesized scope (phase, for_each, do-loop, op template) is built. A value the child’s input refuses is an error.

pub fn bind_under( &self, parent: &dyn Kernel, bindings: &[(String, Value)], ) -> Result<Self, String>

Another instance of this scope’s program under parent, with bindings written into its inputs first — the any-engine form of for_iteration(canonical, parent, bindings), and of build_subscope with program matter.

pub fn fork(&self) -> Self

A copy of this scope with its state — inputs, outputs, cells shared (native_scope_trees.md §4): a fiber’s starting kernel, an activation scope, a probe that leaves this one undisturbed.

pub fn program(&self) -> &Arc<PolydatProgram>

The interpreter program this scope stands for: what synthesis and checkpoint identity read.

pub fn image(&self) -> &Arc<dyn KernelProgram>

The program the running kernel is on.

pub fn module(&self) -> Option<&Arc<OpTemplateModule>>

The module a source-built scope finalized to, from which each fiber instantiates its own kernel with the module’s write-throughs.

pub fn kernel(&self) -> &dyn Kernel

The running kernel.

pub fn into_kernel(self) -> Box<dyn Kernel>

The running kernel, for a holder of a bare dyn Kernel — an adapter’s canonical kernel. Its program_id is this scope’s.

pub fn kernel_mut(&mut self) -> &mut dyn Kernel

The running kernel, mutably.

pub fn lookup(&self, name: &str) -> Option<Value>

A name’s value in this scope without evaluating anything: a const’s value, an input, a value the build folded. A computed output is not a scope value, before or after a pull, on any engine; Self::pull_value evaluates one.

pub fn pull_value(&self, name: &str) -> Option<Value>

A name’s value, evaluating a computed output on a fork so this scope’s state is undisturbed: Self::lookup first, then a pull.

pub fn scope_values(&self) -> Vec<(String, Value)>

The values this scope’s inputs hold, by name, for writing into other kernels: every input with a value except a const’s slot, which only initialization writes (each kernel the values go into initializes its own consts from them).

Trait Implementations

impl Debug for ScopeKernel

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

Formats the value using the given formatter.

impl Deref for ScopeKernel

type Target = dyn Kernel

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for ScopeKernel

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl From<PolydatKernel> for ScopeKernel

fn from(kernel: PolydatKernel) -> Self

An interpreter kernel as a scope: a kernel standing outside the tree’s construction (a test fixture, a probe) that a scope is bound under.

impl IntoSharedScope for ScopeKernel

fn into_shared_scope(self) -> Arc<ScopeKernel>

The scope, shared.

impl Lookup for ScopeKernel

fn lookup(&self, name: &str) -> Option<Value>

The value name denotes here, if any.

fn ledger(&self) -> &Arc<CompileLedger>

The compile ledger of the program tree this scope belongs to: what a source or predicate that has to compile is charged to.

impl ProgramKernel for ScopeKernel

fn split_program(&mut self) -> (&mut dyn Kernel, Arc<PolydatProgram>)

The running kernel and its program.

impl WireSource for ScopeKernel

WireSource over &ScopeKernel — covers names that the kernel’s lookup API already exposes (inputs, scope-init constants, shared-cell-backed values). Computed outputs that require a memoizing pull(&mut state, …) evaluation are NOT covered here and return None from get; the SRD-68 Push 2 work introduces a richer WireSource impl that owns the per-fiber kernel handle with interior mutability and can pull outputs at cycle time.

For Push 1 this &ScopeKernel impl is the additive baseline: every existing call site that gets handed a NullWireSource continues working unchanged, and code that wants kernel-side reads via the trait can use it for the names lookup already answers.

fn get(&self, name: &str) -> Option<Value>

Look up name in this kernel’s scope. Returns the current value (cloned, owned) or None when the name is not declared here. Callers do not retry against another kernel — a None is the resolution result, full stop.

fn names(&self) -> Box<dyn Iterator<Item = String> + '_>

Iterate declared names. Order is implementation-defined. Used by validators and diagnostic renderers.

fn write(&self, _name: &str, _value: Value) -> WriteOutcome

Write value into the named input slot of this kernel. Returns WriteOutcome::Stored when the slot exists and the value was written, WriteOutcome::NoSlot when the kernel’s program has no input slot named name.

fn reset(&self, _name: &str) -> WriteOutcome

Reset the named input slot to its DECLARED initial value — the author’s identity element for that wire. The capture layer uses this for min/max-of-nothing (SRD-93-era fold totality): an empty measurement restores the wire to its declared unit rather than parking Value::None on a typed slot, where every downstream consumer would have to be None-aware. Default impl returns NoSlot (read-only sources have nothing to reset).

fn advance(&self, _coord: u64)

Advance the underlying kernel state to coordinate coord and invalidate any memoized pulls so subsequent get calls produce values for this coord.