Struct Memo

pub struct Memo<T> { /* private fields */ }

Derived read-only value computed from signals or other memos.

A memo stores functions, not a cached value. Every Self::read evaluates its closure again. Clones share the same closures through Rc and are neither Send nor Sync. Revision reporting is advisory: Self::new always reports zero, while memos derived through Signal::map propagate their source revision.

A memo is dynamically reactive when its computation reads a Signal or super::State during a retained build, layout, or paint callback, even if its advisory revision is zero. Only sources reached by the executed branch are observed. After the surrounding callback succeeds, that conditional set atomically replaces the callback’s previous observations; a panic leaves the previous set active. Reads outside retained callbacks are passive.

Examples

use std::{cell::Cell, rc::Rc};
use ailloli_ui_runtime::component::Memo;
let calls = Rc::new(Cell::new(0));
let observed = calls.clone();
let memo = Memo::new(move || { observed.set(observed.get() + 1); 7 });
assert_eq!((memo.read(), memo.read()), (7, 7));
assert_eq!(calls.get(), 2);

Implementations

impl<T> Memo<T>

Provides the operations defined for Memo<T>.

pub fn new(read_fn: impl Fn() -> T + 'static) -> Self

Creates an opaque lazy computation with constant revision zero.

read_fn is not evaluated during construction and its outputs are not cached. If it reads a signal during a retained callback, that signal is observed dynamically even though Self::revision remains zero. Other mutable external state can change without notifying the retained runtime.

Examples

use ailloli_ui_runtime::component::Memo;
let memo = Memo::new(|| 21 * 2);
assert_eq!(memo.read(), 42);
assert_eq!(memo.revision(), 0);

pub fn read(&self) -> T

Evaluates and returns the current derived value.

Panics

Any panic from the stored computation propagates to the caller.

Examples

use ailloli_ui_runtime::component::Memo;
let memo = Memo::new(|| String::from("fresh"));
assert_eq!(memo.read(), "fresh");

pub fn revision(&self) -> u64

Evaluates the memo’s advisory revision function.

A standalone memo returns zero. Derived signal memos return the source’s nonzero-after-change wrapping revision. This call does not read the value, but a signal-derived revision function observes that signal when invoked during a retained callback.

Examples

use ailloli_ui_runtime::component::Memo;
let memo = Memo::new(|| 1);
assert_eq!(memo.revision(), 0);

pub fn map<U: 'static>(&self, f: impl Fn(T) -> U + 'static) -> Memo<U>

where T: 'static,

Lazily maps this memo while preserving its revision function.

Neither the source nor result is cached; each result read first evaluates the source and then f.

Examples

use ailloli_ui_runtime::component::Memo;
let source = Memo::new(|| 5);
let label = source.map(|value| format!("value={value}"));
assert_eq!(label.read(), "value=5");
assert_eq!(label.revision(), 0);

impl<T> Memo<T>

where T: Display + 'static,

pub fn to_text(&self) -> Memo<String>

Lazily formats each source value through ToString::to_string.

Examples

use ailloli_ui_runtime::component::Memo;
assert_eq!(Memo::new(|| 8).to_text().read(), "8");

impl<T> Memo<T>

where T: 'static,

pub fn to_text_with<F>(&self, format: F) -> Memo<String>

where F: Fn(T) -> String + 'static,

Lazily formats each source value with format.

Examples

use ailloli_ui_runtime::component::Memo;
let text = Memo::new(|| 8).to_text_with(|value| format!("{value}px"));
assert_eq!(text.read(), "8px");

Trait Implementations

impl<T> Clone for Memo<T>

Implements the Clone contract for Memo<T>.

fn clone(&self) -> Self

Produces the clone required by the standard cloning contract.

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

Performs copy-assignment from source.

impl<T> From<Memo<T>> for Binding<T>

Implements the From<Memo<T>> contract for Binding<T>.

fn from(value: Memo<T>) -> Self

Performs the documented infallible conversion.