State, Signals, and Effects

Repose uses a small reactive core instead of an explicit widget tree with mutable fields. There are three main pieces:

• Signal<T> - observable, reactive value.
• remember* - lifecycle‑aware storage bound to composition.
• effect / scoped_effect - side‑effects with cleanup.

Signals

Signal<T> is a cloneable handle to a piece of state:

use repose_core::*;

let count = signal(0);
count.set(1);
count.update(|v| *v += 1);
assert_eq!(count.get(), 2);

Reads participate in a dependency graph: when you call get() inside an observer or produce_state, future writes will automatically recompute that observer.

Remembered state

UI state is typically held in remember_* slots rather than globals:

use repose_core::*;

fn CounterView() -> View {
    let count = remember_mutable(|| 0); // auto-requests a frame on set/update

    let on_click = {
        let count = count.clone();
        move || count.update(|c| *c += 1)
    };

    repose_ui::Button(
        format!("Count = {}", *count.get()),
        on_click,
    )
}

• remember and remember_mutable are order‑based: the Nth call in a composition slot always refers to the Nth stored value.
• remember_with_key and remember_state_with_key are key‑based and more stable across conditional branches.

Derived state

produce_state computes a Signal<T> from other signals and recomputes it automatically when dependencies change:

use repose_core::*;

let first = signal("Jane".to_string());
let last  = signal("Doe".to_string());

let full = produce_state("full_name", {
    let first = first.clone();
    let last  = last.clone();
    move || format!("{} {}", first.get(), last.get())
});

assert_eq!(full.get(), "Jane Doe");

Effects and cleanup

Use scoped_effect_once / disposable_effect for mount-once side-effects with cleanups:

use repose_core::*;

fn Example() -> View {
    scoped_effect_once(|| {
        log::info!("Mounted Example");
        on_unmount(|| log::info!("Unmounted Example"))
    });

    // ...
    repose_ui::Box(Modifier::new())
}

• effect / scoped_effect run on every call and register cleanup on the current Scope. Called directly in a composable body they re-run every frame - use effect_once / scoped_effect_once for mount-once setup.
• disposable_effect(key, ..) re-runs on key change and cleans up on unmount (callsite-keyed, branch-stable).
• launched_effect!(key, ..) is the cancellable launched variant; launched_effect_uncancelled! is explicit fire-and-forget.

For long‑running tasks (network, timers), prefer building small helpers on top of disposable_effect so everything cleans up correctly when the UI that owns it disappears.