Struct ScopeKernel 

pub struct ScopeKernel<M> { /* private fields */ }

Typed wrapper around a kernel of any engine.

Construction via this type goes through the subcontext protocol (subcontext_builder → finalize → spawn), which builds each child on its parent’s engine; a root is wrapped with wrap_root_kernel.

Implementations

impl<M> ScopeKernel<M>

pub fn shared_cells_in_scope(&self) -> Vec<SharedCellInScope>

Enumerate every shared cell visible at this scope: the kernel’s Kernel::cells_in_scope, its own and those it carries for its descendants.

pub fn name(&self) -> &ChildName

The structured name this kernel was spawned under (for child kernels) or its self-label (for root kernels).

pub fn site(&self) -> &SourceContext

Diagnostic site for this kernel’s construction.

pub fn lock_inner(&self) -> MutexGuard<'_, Box<dyn Kernel>>

Borrow the underlying kernel. The lock is released when the returned guard is dropped. Exposed for callers that drive the kernel directly.

pub fn consumers(&self) -> Vec<RegisteredPullConsumer>

The pull consumers registered with this kernel. Used by the activity-side fixture adapter at seal time.

pub fn has_child(&self, name: &ChildName) -> bool

Whether name is recorded in this kernel’s named-child registry. Diagnostic; the subcontext tests assert against this.

pub fn release_child(&self, name: &ChildName)

Drop the named child from this kernel’s registry. The child kernel itself is unaffected — only the registry entry. After release, the same name may be spawned again (typical for comprehension scopes that re-traverse per iteration). See subcontext_construction.md §4.1.

pub fn subcontext_builder(&self) -> SubcontextBuilder<M>

Begin construction of a child sub-context (subcontext_construction.md §1): the builder takes the parent’s ParentView — its names, modifiers, ledger, and in-scope cells, which is everything finalize reads of a parent — accumulates module matter, and produces a closed ScopeModule artifact at finalize. It holds no reference to the parent kernel, so a caller that only has a kernel needs no ScopeKernel to stand up a child.

pub fn spawn( self: &Arc<Self>, name: ChildName, artifact: ScopeModule<Child<M>>, ) -> Result<ScopeKernel<Child<M>>, ContractViolation>

Spawn a child kernel from a closed ScopeModule artifact (subcontext_construction.md §4): this is the single chokepoint where every cross-binding is resolved.

The artifact arrives with Rule 1 (name closure) and Rule 2 (the shared write-through rewrite) already applied by SubcontextBuilder::finalize. Spawn instantiates the closed program on this parent’s engine (ScopeModule::instantiate_under), whose binder does the live binding: attaches every parent-visible SharedCell to a matching child slot and forwards the rest as transit (Rule 2’s cell attach, SC8), value-copies or cell-attaches parent outputs into child externs (Rules 4 and 5), initializes the child so its consts see post-bind inputs (Rule 3), and freezes the scope coordinates. A refused copy or a failing const is ContractViolation::Bind. Per-cycle publication to the cells is Self::commit_write_throughs.

pub fn write_throughs(&self) -> &[WriteThroughBinding]

The Rule 2 write-through bindings carried by this kernel. Empty for the vast majority of kernels; populated only when the artifact’s finalize rewrote a child export to a parent shared cell write.

pub fn commit_write_throughs(&self) -> Result<(), String>

Per-cycle Rule 2 commit: pulls every write-through’s synthetic source output (__write_<X>) and stores its value through the corresponding child input slot for <X>. Because materialize_wiring_from_outer attached the parent’s SharedCell to that slot, the write propagates to the cell, where it becomes visible to the parent and to any sibling that shares the same cell.

No-op for kernels with no write-throughs.

TYPE-STABLE (scope_model.md §6.1): each pending value passes the boundary of Kernel::commit_write_throughs: matching types pass, catalog adapters heal (widening), and an unhealable mismatch is an Err at the write site.

Trait Implementations

impl<M> Debug for ScopeKernel<M>

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

Formats the value using the given formatter.