Struct Elements 

pub struct Elements { /* private fields */ }

A list of component descriptions for declarative tree building.

Elements is what view functions return and what the framework reconciles against the existing component tree. Build one with the element! macro or the imperative API:

// With the element! macro (preferred):
fn my_view(state: &MyState) -> Elements {
    element! {
        "Hello"
        #(if state.loading {
            Spinner(key: "spinner", label: "Loading...")
        })
    }
}

// Imperative API:
fn my_view(state: &MyState) -> Elements {
    let mut els = Elements::new();
    els.add(Text::unstyled("Hello"));
    if state.loading {
        els.add(Spinner::new("Loading...")).key("spinner");
    }
    els
}

Implementations

impl Elements

pub fn new() -> Self

Create an empty element list.

Examples found in repository

examples/lifecycle.rs (line 109)

fn task_view(state: &AppState) -> Elements {
    let mut els = Elements::new();

    els.add(Text::styled(
        format!("Tasks ({})", state.tasks.len()),
        Style::default()
            .fg(Color::White)
            .add_modifier(Modifier::BOLD),
    ));

    for task in &state.tasks {
        els.add(StatusLog::new(task)).key(task.clone());
    }

    if state.processing {
        els.add(Spinner::new("Processing...")).key("spinner");
    }

    els.add(Text::styled("---", Style::default().fg(Color::DarkGray)));

    els
}

pub fn add<C: Component>(&mut self, component: C) -> ElementHandle<'_>

Add a component to the list.

Returns an ElementHandle that can be used to set a key for stable identity across rebuilds.

Examples found in repository

examples/lifecycle.rs (lines 111-116)

fn task_view(state: &AppState) -> Elements {
    let mut els = Elements::new();

    els.add(Text::styled(
        format!("Tasks ({})", state.tasks.len()),
        Style::default()
            .fg(Color::White)
            .add_modifier(Modifier::BOLD),
    ));

    for task in &state.tasks {
        els.add(StatusLog::new(task)).key(task.clone());
    }

    if state.processing {
        els.add(Spinner::new("Processing...")).key("spinner");
    }

    els.add(Text::styled("---", Style::default().fg(Color::DarkGray)));

    els
}

pub fn add_with_children<C: Component>( &mut self, component: C, children: Elements, ) -> ElementHandle<'_>

Add a component with nested children.

The component is created first, then children are built as its descendants. The component’s children() method receives these as the slot parameter.

pub fn group(&mut self, children: Elements) -> ElementHandle<'_>

Add a VStack wrapper around the given children.

Equivalent to add_with_children(VStack, children).

pub fn hstack(&mut self, children: Elements) -> ElementHandle<'_>

Add an HStack wrapper around the given children.

Children default to WidthConstraint::Fill. Use .width(WidthConstraint::Fixed(n)) for fixed-width children.

pub fn splice(&mut self, other: Elements)

Splice another Elements list into this one.

All entries from other are appended to this list. This is used by the element! macro’s #(expr) syntax to interpolate pre-built Elements inline.

impl Elements

pub fn is_empty(&self) -> bool

Whether this element list is empty.

Trait Implementations

impl<C: Component> AddTo<Elements> for ComponentWithSlot<C>

type Handle<'a> = ElementHandle<'a>

Handle returned after adding. Supports .key() / .width() chaining.

fn add_to(self, els: &mut Elements) -> ElementHandle<'_>

Add this value to the collector, returning a handle for chaining .key() and .width().

impl AddTo<Elements> for String

String → Elements: creates a Text component with the string as content.

This powers the element! string literal sugar — "hello" becomes a Text component. The same AddTo dispatch also works inside data children contexts (e.g., Text { "hello" }) via the Into<TextChild> blanket impl.

type Handle<'a> = ElementHandle<'a>

Handle returned after adding. Supports .key() / .width() chaining.

fn add_to(self, els: &mut Elements) -> ElementHandle<'_>

Add this value to the collector, returning a handle for chaining .key() and .width().

impl Default for Elements

fn default() -> Self

Returns the “default value” for a type.

impl SpliceInto<Elements> for Elements

fn splice_into(self, collector: &mut Elements)

Splice all entries from this value into the collector.