Enum VirtualNode 

pub enum VirtualNode<T = ()> {
    Element {
        tag: Tag,
        attributes: Vec<AttributeEntry>,
        children: Vec<VirtualNode>,
        key: Option<String>,
        props: Option<Box<T>>,
    },
    Text(TextNode),
    Fragment(Vec<VirtualNode>),
    Dynamic(DynamicNode),
    Empty,
}

Represents a node in the virtual DOM tree.

The core enum representing elements, text, fragments, and empty nodes. The generic parameter T carries the component props type for component nodes. For non-component nodes, T defaults to ().

Variants

Element

An element node with a tag, attributes, children, and optional props.

Fields

tag: Tag

The tag type of this element.

attributes: Vec<AttributeEntry>

The attributes attached to this element.

children: Vec<VirtualNode>

The child nodes.

key: Option<String>

An optional key for diffing.

props: Option<Box<T>>

The component props, present only for component nodes.

Text(TextNode)

A text node containing string content and an optional reactive signal.

Fragment(Vec<VirtualNode>)

A fragment of multiple nodes without a wrapper element.

Dynamic(DynamicNode)

A dynamic node that re-renders based on signal changes.

Empty

An empty placeholder node.

Implementations

impl<T> VirtualNode<T>

Implementation of virtual node construction and property extraction.

pub fn try_get_tag_name(&self) -> Option<String>

Returns the tag name if this is an element or component node.

Returns

• Option<String> - The tag name, or None if not an element.

pub fn try_get_children(&self) -> Option<&Vec<VirtualNode>>

Returns a reference to the children of this node, if it has any.

Returns Some for Element and Fragment variants, None otherwise.

Returns

• Option<&Vec<VirtualNode>> - The children, or None.

pub fn has_children(&self) -> bool

Returns true if this node has non-empty children.

Returns

• bool - Whether this node has children.

pub fn try_get_props(&self) -> Option<T>

where T: Clone,

Clones the props of this node.

Returns

• Option<T> - The cloned props, or None if this node has no props.

pub fn try_get_child_node(&self) -> Option<VirtualNode>

Returns the children of this node as a virtual node.

Returns VirtualNode::Empty when there are no children, a single child when there is exactly one, or VirtualNode::Fragment when there are multiple children.

Returns

• Option<VirtualNode> - The children as a virtual node.

pub fn extend_attributes<I>(self, extra: I) -> Self

where I: IntoIterator<Item = AttributeEntry>,

Extends this node’s attribute list with the given entries, then returns the node. If the node is not an Element variant, the entries are dropped and the node is returned unchanged.

Used by the html! macro to splice class / style / event handler attributes onto a component-returned node without forcing a let mut binding in the generated code.

Arguments

• I: IntoIterator<Item = AttributeEntry> - The extra entries to append.

Returns

• Self - The node with extended attributes (or unchanged).

pub fn get_child_node(&self) -> VirtualNode

Returns the children of this node as a virtual node.

Returns VirtualNode::Empty when there are no children, a single child when there is exactly one, or VirtualNode::Fragment when there are multiple children.

Returns

• VirtualNode - The children as a virtual node.

pub fn key(&self) -> Option<&str>

Returns the diffing key of this node, if it has one.

Recognizes keys on Element variants. Other variants (Text, Fragment, Dynamic, Empty) do not have keys. This matches the renderer’s get_node_key semantics in core/src/renderer/render/impl.rs.

Returns

• Option<&str> - The key, or None if this node has no key or is not an Element variant.

pub fn has_key(&self) -> bool

Returns true if this node has a non-None diffing key.

Returns

• bool - true if key() returns Some, false otherwise.

impl VirtualNode<()>

Implementation of virtual node construction for VirtualNode<()>.

pub fn create_dynamic<F>(render_fn: F) -> Self

where F: FnMut(&mut HookContext) -> Self + 'static,

Creates a dynamic node with the given render function.

Arguments

• F: FnMut(&mut HookContext) -> Self + 'static - The render function.

Returns

• Self - The dynamic node.

Trait Implementations

impl<T: Clone> Clone for VirtualNode<T>

Clones a VirtualNode<T> by deep-copying all fields.

fn clone(&self) -> Self

Clones the VirtualNode by reusing shared, cheap-to-clone state where possible.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for VirtualNode<T>

Debug formatting for VirtualNode<T>.

Skips Dynamic inner details and props for brevity.

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

Formats the VirtualNode via the supplied formatter.

Arguments

• &mut Formatter<'_> - The formatter receiving the formatted output.

Returns

• fmt::Result - Result of the formatting operation.

impl<T> Default for VirtualNode<T>

Default implementation returns VirtualNode::Empty.

fn default() -> Self

Constructs a default VirtualNode value.

impl From<&str> for VirtualNode

Converts a &str into a text virtual node.

fn from(text: &str) -> Self

Converts this string slice into a text virtual node.

Returns

• VirtualNode - A text virtual node.

Arguments

• &str - Input value to convert from.

impl<F> From<F> for VirtualNode

where F: FnMut(&mut HookContext) -> VirtualNode + 'static,

Wraps a FnMut(&mut HookContext) -> VirtualNode closure into a DynamicNode.

This enables writing {move |_: &mut HookContext| html! { ... }} directly in HTML markup without explicit DynamicNode construction.

fn from(render_fn: F) -> Self

Wraps this closure into a VirtualNode::Dynamic with a fresh hook context.

Returns

• VirtualNode - A dynamic virtual node wrapping this closure.

Arguments

• F - Input value to convert from.

impl From<Option<Vec<VirtualNode>>> for VirtualNode

Converts an Option<Vec<VirtualNode>> into a VirtualNode.

Some(vec) converts the vector into a VirtualNode::Fragment (or Empty if the vector is empty), None returns VirtualNode::Empty.

Returns

• VirtualNode - A VirtualNode::Fragment if Some with nodes, VirtualNode::Empty if None or the vector is empty.

fn from(nodes: Option<Vec<VirtualNode>>) -> Self

Lifts an Option<Vec<VirtualNode>> into a VirtualNode (unwraps or falls back to empty).

Arguments

• Option<Vec<VirtualNode>> - Input value to convert from.

impl From<Option<VirtualNode>> for VirtualNode

Converts an Option<VirtualNode> into a VirtualNode.

Some(node) returns the inner node, None returns VirtualNode::Empty.

Returns

• VirtualNode - The inner node if Some, otherwise VirtualNode::Empty.

fn from(node: Option<VirtualNode>) -> Self

Lifts an Option<VirtualNode> into a VirtualNode (unwraps or falls back to empty).

Arguments

• Option<VirtualNode> - Input value to convert from.

impl<T> From<Signal<T>> for VirtualNode

where T: Clone + PartialEq + Display + 'static,

Converts a signal into a reactive text virtual node.

fn from(signal: Signal<T>) -> Self

Converts this signal into a reactive text virtual node.

Returns

• VirtualNode - A reactive text virtual node.

Arguments

• Signal<T> - Input value to convert from.

impl From<String> for VirtualNode

Converts a String into a text virtual node.

fn from(text: String) -> Self

Converts this string into a text virtual node.

Returns

• VirtualNode - A text virtual node.

Arguments

• String - Input value to convert from.

impl From<Vec<VirtualNode>> for VirtualNode

Converts a Vec<VirtualNode> into a VirtualNode::Fragment.

This enables using a Vec<VirtualNode> directly in the html! macro without manually wrapping it in VirtualNode::Fragment(...).

Returns

• VirtualNode - A VirtualNode::Fragment containing the nodes, or VirtualNode::Empty if the vector is empty.

fn from(nodes: Vec<VirtualNode>) -> Self

Lifts a Vec<VirtualNode> into a single VirtualNode via wrapping or unwrapping.

Arguments

• Vec<VirtualNode> - Input value to convert from.

impl From<bool> for VirtualNode

Converts a bool into a text virtual node.

fn from(value: bool) -> Self

Converts this boolean into a text virtual node.

Returns

• VirtualNode - A text virtual node.

Arguments

• bool - Input value to convert from.

impl From<i32> for VirtualNode

Converts an i32 into a text virtual node.

fn from(value: i32) -> Self

Converts this integer into a text virtual node.

Returns

• VirtualNode - A text virtual node.

Arguments

• i32 - Input value to convert from.

impl From<usize> for VirtualNode

Converts a usize into a text virtual node.

fn from(value: usize) -> Self

Converts this unsigned integer into a text virtual node.

Returns

• VirtualNode - A text virtual node.

Arguments

• usize - Input value to convert from.

impl<T: PartialEq> PartialEq for VirtualNode<T>

Visual equality comparison for virtual DOM nodes.

Used by DynamicNode re-rendering to skip unnecessary DOM patches when the rendered output has not changed. Event attributes are always considered equal because re-binding event listeners is handled separately by the handler registry and does not affect visual output. Dynamic nodes manage their own subtree re-rendering, so two Dynamic variants are always considered equal — the inner renderer handles patching when the dynamic content actually changes.

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

Returns true when self and other are equivalent by the PartialEq contract.

Arguments

• &Self - The other value to compare against self.

Returns

• bool - true when self and other are equivalent by the trait contract.

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

Inequality operator !=.