Enum ScopeKind 

pub enum ScopeKind {
    Session,
    Workload,
    Scenario {
        name: String,
    },
    Comprehension {
        comprehension: Comprehension,
    },
    IncludedScenario {
        name: String,
    },
    DoWhile {
        condition: String,
        counter: Option<String>,
    },
    DoUntil {
        condition: String,
        counter: Option<String>,
    },
    Phase {
        name: String,
    },
    OpTemplate {
        name: String,
    },
    Bindings {
        source: String,
    },
}

What kind of scope a ScopeNode represents. Mirrors the ScenarioNode variants 1:1, with two extra kinds for the implicit workload root and the named scenario layer that wraps the user’s authored children. SRD 18b §“Canonical traversal”.

Variants

Session

The session root — one per process (SRD-88). The shared common root every execution derives from: it owns the session polydat scope (the process/session-level args) and the session=<id> identity. Each ScopeKind::Workload hangs under it as one execution. For a single-execution run there is exactly one workload child.

Workload

A workload root — one per execution (SRD-88). Owns the outer Polydat Kernel for its workload, compiled at execution start, binding the session scope as its outer.

Scenario

A named scenario. Wraps the scenario’s children so that “phase P in scenario default” survives as a path query rather than a elided label.

Fields

name: String

Comprehension

Iteration scope — for_each (single or multi-clause) or for_each_union. The Comprehension AST captures the shape and clauses; the executor uses it to enumerate tuples and bind iteration variables on per-iteration child kernels.

Fields

comprehension: Comprehension

IncludedScenario

Logical inclusion of another scenario by name. The runtime walks straight through to the children; the scope is preserved purely so the scope tree retains the include hierarchy for dryrun=phase and TUI output. See nmbrs_workload::model::ScenarioNode::IncludedScenario.

Fields

name: String

DoWhile

do_while with optional counter as a scope output.

Fields

condition: String

counter: Option<String>

DoUntil

do_until with optional counter as a scope output.

Fields

condition: String

counter: Option<String>

Phase

A phase reference. With SRD-13d Phase 6 the phase is no longer a leaf — every op template the phase declares becomes an OpTemplate child of this node. The kernel slot, if filled, holds the per-phase Polydat program.

Fields

name: String

OpTemplate

SRD-13d Phase 6 — an op template’s scope, child of its declaring phase. Per-template Polydat content (bindings:, metrics: wire-injections, inline {{<expr>}} rewrites) hangs off this node; the scope-elision pre-walk (§3.3) decides whether it materialises its own kernel or elides into the parent phase. Op-template scopes also own per-op Component instances at runtime so SRD-40b’s duplicate-family check (via Component::register_instrument) surfaces per-op rather than per-phase.

Fields

name: String

Bindings

Scenario-tree-level Polydat bindings block (see nmbrs_workload::model::ScenarioNode::Bindings). The source is Polydat matter text that compiles into a kernel layered over the parent scope. Used for any scope-tree- level state injection: workload-param shadowing (the set: { ... } sugar form), derived bindings spanning a subtree, shared cells, etc. — the Polydat grammar is the only constraint on what the source may contain.

Fields

source: String

Implementations

impl ScopeKind

pub fn opens_kernel(&self) -> bool

True if this kind opens a new Polydat scope (its own kernel + pragmas + extern wiring). Phase scopes are only “new” when the phase has its own bindings or it’s an iteration of a parent — that decision lives in the compiler step, not this static descriptor.

pub fn label(&self) -> String

Short label for diagnostic output (dryrun=phase, TUI).

Trait Implementations

impl Clone for ScopeKind

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ScopeKind

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

Formats the value using the given formatter.