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 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.

impl VirtualNode

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

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

where F: FnMut(&mut HookContext) -> VirtualNode + '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 for VirtualNode<T>

where T: Clone,

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

fn clone(&self) -> VirtualNode<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for VirtualNode<T>

where T: Debug,

Debug formatting for VirtualNode<T>.

Skips Dynamic inner details and props for brevity.

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

Formats the value using the given formatter.

impl<T> Default for VirtualNode<T>

Default implementation returns VirtualNode::Empty.

fn default() -> VirtualNode<T>

Returns the “default value” for a type.

impl From<&str> for VirtualNode

Converts a &str into a text virtual node.

fn from(text: &str) -> VirtualNode

Converts this string slice into a text virtual node.

Returns

• VirtualNode - A text virtual node.

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) -> VirtualNode

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

Returns

• VirtualNode - A dynamic virtual node wrapping this closure.

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>>) -> VirtualNode

Converts to this type from the input type.

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>) -> VirtualNode

Converts to this type from the input type.

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>) -> VirtualNode

Converts this signal into a reactive text virtual node.

Returns

• VirtualNode - A reactive text virtual node.

impl From<String> for VirtualNode

Converts a String into a text virtual node.

fn from(text: String) -> VirtualNode

Converts this string into a text virtual node.

Returns

• VirtualNode - A text virtual node.

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>) -> VirtualNode

Converts to this type from the input type.

impl From<bool> for VirtualNode

Converts a bool into a text virtual node.

fn from(value: bool) -> VirtualNode

Converts this boolean into a text virtual node.

Returns

• VirtualNode - A text virtual node.

impl From<i32> for VirtualNode

Converts an i32 into a text virtual node.

fn from(value: i32) -> VirtualNode

Converts this integer into a text virtual node.

Returns

• VirtualNode - A text virtual node.

impl From<usize> for VirtualNode

Converts a usize into a text virtual node.

fn from(value: usize) -> VirtualNode

Converts this unsigned integer into a text virtual node.

Returns

• VirtualNode - A text virtual node.

impl<T> PartialEq for VirtualNode<T>

where T: PartialEq,

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: &VirtualNode<T>) -> 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.