Struct Memo 

pub struct Memo<T>(/* private fields */);

A shared lazy cache of a pure computation over tracked signals and memos.

Reads validate dependencies synchronously, including inside a batch. Equal results keep the previous cached value and suppress downstream effects that have no other changed dependencies. Keep a handle alive while using the memo; dropping the last handle releases its cache, captures, and subscriptions. Computation and equality functions must be pure. Managed signal writes and effect creation during evaluation panic before changing reactive state.

Implementations

impl<T: 'static> Memo<T>

pub fn with<R>(&self, read: impl FnOnce(&T) -> R) -> R

Borrow the current cached value and subscribe the consuming effect/memo. Do not change dependencies while this callback borrows the cache.

pub fn with_untracked<R>(&self, read: impl FnOnce(&T) -> R) -> R

Read without subscribing the caller. The memo still tracks its own inputs.

impl<T: Clone + 'static> Memo<T>

pub fn get(&self) -> T

Examples found in repository

examples/memo_workload.rs (line 23)

fn run(name: &str, cached: bool, consumers: usize, updates: u64, work: u64, group: u64) {
    let input = signal(0_u64);
    let computations = Rc::new(Cell::new(0_u64));
    let renders = Rc::new(Cell::new(0_u64));
    let compute = {
        let (input, computations) = (input.clone(), computations.clone());
        move || {
            computations.set(computations.get() + 1);
            let mut n = input.get() / group;
            for _ in 0..work {
                n = black_box(n.wrapping_mul(6364136223846793005).wrapping_add(1));
            }
            n
        }
    };
    let read: Rc<dyn Fn() -> u64> = if cached {
        let value = memo(compute);
        Rc::new(move || value.get())
    } else {
        let value = derived(compute);
        Rc::new(move || value.get())
    };
    let subscriptions: Vec<_> = (0..consumers)
        .map(|_| {
            let (read, renders) = (read.clone(), renders.clone());
            effect(move || {
                black_box(read());
                renders.set(renders.get() + 1);
            })
        })
        .collect();
    computations.set(0);
    renders.set(0);
    let start = Instant::now();
    for value in 1..=updates {
        input.set(black_box(value));
    }
    let elapsed = start.elapsed().as_micros();
    let mode = if cached { "Memo" } else { "Derived" };
    println!(
        "{name},{mode},{consumers},{updates},{},{},{elapsed}",
        computations.get(),
        renders.get()
    );
    assert_eq!(
        computations.get(),
        updates * if cached { 1 } else { consumers as u64 }
    );
    assert_eq!(
        renders.get(),
        if cached { updates / group } else { updates } * consumers as u64
    );
    drop(subscriptions);
}

pub fn get_untracked(&self) -> T

Trait Implementations

impl<T> Clone for Memo<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.