Struct SlotTable 

pub struct SlotTable { /* private fields */ }

Implementations

impl SlotTable

pub fn new() -> Self

pub fn current_group(&self) -> usize

pub fn group_key(&self, index: usize) -> Option<Key>

pub fn mark_range_as_gaps( &mut self, start: usize, end: usize, owner_index: Option<usize>, ) -> bool

Mark a range of slots as gaps instead of truncating. This preserves sibling components while allowing structure changes. When encountering a Group, recursively marks the entire group structure as gaps.

pub fn get_group_scope(&self, index: usize) -> Option<usize>

pub fn set_group_scope(&mut self, index: usize, scope: usize)

pub fn find_group_index_by_scope(&self, scope: usize) -> Option<usize>

pub fn start_recranpose_at_scope(&mut self, scope: usize) -> Option<usize>

pub fn debug_dump_groups(&self) -> Vec<(usize, Key, Option<usize>, usize)>

pub fn debug_dump_all_slots(&self) -> Vec<(usize, String)>

pub fn start(&mut self, key: Key) -> usize

pub fn end(&mut self)

pub fn skip_current(&mut self)

pub fn node_ids_in_current_group(&self) -> Vec<NodeId>

pub fn use_value_slot<T: 'static>(&mut self, init: impl FnOnce() -> T) -> usize

pub fn read_value<T: 'static>(&self, idx: usize) -> &T

pub fn read_value_mut<T: 'static>(&mut self, idx: usize) -> &mut T

pub fn write_value<T: 'static>(&mut self, idx: usize, value: T)

pub fn read_value_by_anchor<T: 'static>(&self, anchor: AnchorId) -> Option<&T>

Read a value slot by its anchor ID. Provides stable access even if the slot’s position changes.

pub fn read_value_mut_by_anchor<T: 'static>( &mut self, anchor: AnchorId, ) -> Option<&mut T>

Read a mutable value slot by its anchor ID.

pub fn remember<T: 'static>(&mut self, init: impl FnOnce() -> T) -> Owned<T>

pub fn remember_with_anchor<T: 'static>( &mut self, init: impl FnOnce() -> T, ) -> (usize, AnchorId)

Remember a value and return both its index and anchor ID. The anchor provides stable access even if the slot’s position changes.

pub fn record_node(&mut self, id: NodeId)

pub fn peek_node(&self) -> Option<NodeId>

pub fn read_node(&mut self) -> Option<NodeId>

pub fn advance_after_node_read(&mut self)

pub fn reset(&mut self)

pub fn step_back(&mut self)

Step the cursor back by one position. Used when we need to replace a slot that was just read but turned out to be incompatible.

pub fn trim_to_cursor(&mut self) -> bool

Trim slots by marking unreachable slots as gaps.

Instead of blindly truncating at cursor position, this method:

1. Marks slots from cursor to end of current group as gaps
2. Keeps the group length unchanged (gaps are part of the group’s physical extent)
3. Preserves sibling components outside the current group

This ensures effect states (LaunchedEffect, etc.) are preserved even when conditional rendering changes the composition structure.

Key insight: Gap slots remain part of the group’s physical length. The group’s len field represents its physical extent in the slots array, not the count of active slots. This allows gap slots to be found and reused in subsequent compositions.

Trait Implementations

impl Default for SlotTable

fn default() -> SlotTable

Returns the “default value” for a type.

impl SlotStorage for SlotTable

Baseline SlotStorage implementation using a gap-buffer strategy.

This is the reference / most-feature-complete backend, supporting:

• Gap-based slot reuse (preserving sibling state during conditional rendering)
• Anchor-based positional stability during group moves and insertions
• Efficient group skipping and recomposition via scope-based entry
• Batch anchor rebuilding for large structural changes

Implementation Strategy: Uses UFCS (Uniform Function Call Syntax) to delegate to SlotTable’s inherent methods, avoiding infinite recursion while keeping the trait implementation clean.

type Group = GroupId

Opaque handle to a started group.

type ValueSlot = ValueSlotId

Opaque handle to a value slot.

fn begin_group(&mut self, key: Key) -> StartGroup<Self::Group>

Begin a group with the given key.

fn set_group_scope(&mut self, group: Self::Group, scope: usize)

Associate the runtime recomposition scope with this group.

fn end_group(&mut self)

End the current group.

fn skip_current_group(&mut self)

Skip over the current group (used by the “skip optimization” in the macro).

fn nodes_in_current_group(&self) -> Vec<NodeId>

Return node ids that live in the current group (needed so the composer can reattach them to the parent when skipping).

fn begin_recranpose_at_scope(&mut self, scope: usize) -> Option<Self::Group>

Start recomposing the group that owns scope. Returns the group we started, or None if that scope is gone.

fn end_recompose(&mut self)

Finish the recomposition started with begin_recranpose_at_scope.

fn alloc_value_slot<T: 'static>( &mut self, init: impl FnOnce() -> T, ) -> Self::ValueSlot

Allocate or reuse a value slot at the current cursor.

fn read_value<T: 'static>(&self, slot: Self::ValueSlot) -> &T

Immutable read of a value slot.

fn read_value_mut<T: 'static>(&mut self, slot: Self::ValueSlot) -> &mut T

Mutable read of a value slot.

fn write_value<T: 'static>(&mut self, slot: Self::ValueSlot, value: T)

Overwrite an existing value slot.

fn remember<T: 'static>(&mut self, init: impl FnOnce() -> T) -> Owned<T>

Convenience “remember” built on top of value slots.

fn peek_node(&self) -> Option<NodeId>

Peek a node at the current cursor (don’t advance).

fn record_node(&mut self, id: NodeId)

Record a node at the current cursor (and advance).

fn advance_after_node_read(&mut self)

Advance after we’ve read a node via the applier path.

fn step_back(&mut self)

Step the cursor back by one (used when we probed and need to overwrite).

fn finalize_current_group(&mut self) -> bool

“Finalize” the current group: mark unreachable tail as gaps. Returns true if we marked gaps (which means children are unstable).

fn reset(&mut self)

Reset to the beginning (used by subcompose + top-level render).

fn flush(&mut self)

Flush any deferred anchor rebuilds.