Struct KernelLookup 

pub struct KernelLookup<'a>(/* private fields */);

A kernel of any engine, as a scope names resolve in.

A host holding a Box<dyn Kernel> interpolates {k} > 5 against the kernel it has through this wrapper, without compiling the program a second time on the interpreter. It is a wrapper rather than an impl Lookup for dyn Kernel because one trait object cannot become another.

Distinct from comprehension::surfaces::KernelScope, the algebra layer’s trait for the parent a comprehension scopes under; this is a Lookup over a kernel that already exists.

Implementations

impl<'a> KernelLookup<'a>

pub fn new(kernel: &'a dyn Kernel) -> KernelLookup<'a>

The kernel as a scope.

Trait Implementations

impl Lookup for KernelLookup<'_>

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

A name resolves to what the kernel holds for it now — an input the host wrote, a coordinate it was positioned at — and otherwise to what the build folded for it. The live answer comes first because it is the later one: a coordinate has a folded value on some engines, and it is the value the program was built with, not the value the kernel is at.

A const binding is the exception. Its value is the scope’s for the name, and an input slot of the same name, which a const that reads a parameter it shadows is given (none_semantics.md, “Conditional-shadow semantics for const”), holds only the value from the scope above. So the const’s own value comes first, and the slot answers only while that value is None: the two-tier read of a conditional shadow.

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.