Enum IRNode 

pub enum IRNode {
    Element(Element),
    ForEach {
        source: Binding,
        item_name: String,
        key_path: Option<String>,
        template: Vec<IRNode>,
        props: Props,
    },
    Conditional {
        value: Value,
        branches: Vec<ConditionalBranch>,
        fallback: Option<Vec<IRNode>>,
    },
}

First-class IR node - distinguishes between regular elements and control flow constructs This provides type-safe pattern matching in the reconciler and clear separation of concerns

Variants

Element(Element)

Regular UI element (Text, Column, Button, etc.)

ForEach

Iteration construct: ForEach(items: ${state.todos}, as: “todo”, key: “id”) { children } Renders template children for each item in an array

Fields

source: Binding

The binding to the array in state (e.g., ${state.todos})

item_name: String

The variable name for each item (default: “item”, can be “todo”, “user”, etc.)

key_path: Option<String>

Optional path to use as key for stable reconciliation (e.g., “id”)

template: Vec<IRNode>

Template children to repeat for each item

props: Props

Additional props for the container element

Conditional

Conditional construct: When(value: ${state.status}) { Case(match: “loading”) {…} Else {…} } Renders matching branch based on evaluated value

Fields

value: Value

The value to match against (binding or static)

branches: Vec<ConditionalBranch>

Branches with patterns to match

fallback: Option<Vec<IRNode>>

Fallback if no branch matches (Else)

Implementations

impl IRNode

pub fn element(element: Element) -> Self

Create an Element IRNode

pub fn for_each( source: Binding, item_name: impl Into<String>, key_path: Option<String>, template: Vec<IRNode>, props: Props, ) -> Self

Create a ForEach IRNode

pub fn conditional( value: Value, branches: Vec<ConditionalBranch>, fallback: Option<Vec<IRNode>>, ) -> Self

Create a Conditional IRNode (When/If)

pub fn as_element(&self) -> Option<&Element>

Get the element if this is an Element variant

pub fn is_for_each(&self) -> bool

Check if this is a ForEach node

pub fn is_conditional(&self) -> bool

Check if this is a Conditional node

Trait Implementations

impl Clone for IRNode

fn clone(&self) -> IRNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IRNode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IRNode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for IRNode

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

where __S: Serializer,

Serialize this value into the given Serde serializer.