Enum InterpolationSlot 

pub enum InterpolationSlot {
    Global(String),
    Row(String),
    RowIndex,
    SelfField(String),
    ParentField(String),
    Arg(String),
}

Round-8 wave-C: classification of a {...} placeholder inside markup. Carries the resolution scope the spawner consults when materializing the slot into a concrete string.

• Global("name") - {$name} or the legacy bare {name}. Resolves against lumen_core::signals::Signals (the global signal map).
• Row("field") - {row.field}, only meaningful inside a <for> body. Resolves against the current iteration’s lumen_core::signals::ArrayItem record. Crucially does not fall through to globals when the row record is missing the field - that substitution emits empty string and a one-shot tracing::warn!.
• RowIndex - {$index} (preferred) or the legacy {idx} alias. Resolves to the 0-based iteration index, stringified.
• SelfField("f") / ParentField("f") - {$self.f} / {$parent.f}. Stub today; the per-entity consumer system lands in a follow-up wave. Substitutes empty string and emits a debug trace.
• Arg("name") - a fragment parameter, resolved from the arguments the use site passed. Only a fragment body carries these: the classifier below cannot produce one, because telling a parameter from a global needs the enclosing fragment’s parameter list, which it cannot see. The fragment builder rewrites Global to Arg for each declared parameter once that scope is known.

Variants

Global(String)

{$name} or {name} legacy shorthand - global signal lookup.

Row(String)

{row.field} - iteration-scope field lookup. <for> body only.

RowIndex

{$index} or {idx} legacy alias - 0-based iteration index.

SelfField(String)

{$self.field} - per-entity field lookup. Stubbed today.

ParentField(String)

{$parent.field} - parent-entity field lookup. Stubbed today.

Arg(String)

A fragment parameter, resolved from the instantiating FragmentUse::args or the parameter’s declared default.

Trait Implementations

impl Clone for InterpolationSlot

fn clone(&self) -> InterpolationSlot

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InterpolationSlot

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for InterpolationSlot

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&str> for InterpolationSlot

fn from(inner: &str) -> Self

Classify a placeholder’s trimmed inner body (without the surrounding {...}). The parser’s interpolation walker uses this to convert each placeholder it finds into a typed slot:

• "$index" / "idx" -> InterpolationSlot::RowIndex.
• "$self.<f>" -> InterpolationSlot::SelfField.
• "$parent.<f>" -> InterpolationSlot::ParentField.
• "row.<f>" -> InterpolationSlot::Row.
• "$name" / "name" -> InterpolationSlot::Global.

InterpolationSlot::Arg is never produced here: a parameter reference is spelled the same as a global, and only the enclosing fragment’s parameter list separates them.

impl PartialEq for InterpolationSlot

fn eq(&self, other: &InterpolationSlot) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for InterpolationSlot

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for InterpolationSlot

impl StructuralPartialEq for InterpolationSlot