Struct Memo

pub struct Memo<T, F>
where
    F: Fn() -> T,
{ /* private fields */ }

A memoized reactive computation that caches its result and tracks dependencies.

Memo<T, F> behaves similarly to a computed property: it stores the result of a closure and only recomputes when its dependencies change. Other signals or effects that access the memo will automatically be tracked.

In short:

• Like a computed property: returns a cached value derived from other signals.
• Adds tracking: recomputes only when dependencies are invalidated.

Type Parameters

• T: The result type of the computation. Must implement Clone.
• F: The closure type that computes the value. Must implement Fn() -> T.

Implementations

impl<T, F> Memo<T, F>

where F: Fn() -> T,

pub fn new(f: F) -> Self

Creates a new Memo wrapping the provided closure.

Examples

use reactive_cache::Memo;

let memo = Memo::new(|| 10);

pub fn get(&'static self) -> T

where T: Clone,

Returns the memoized value, recomputing it only if necessary.

During the computation, dependencies are tracked for reactive updates.

Examples

use once_cell::unsync::Lazy;
use reactive_cache::Memo;

static mut MEMO: Lazy<Memo<i32, fn() -> i32>> = Lazy::new(|| Memo::new(|| 5));
assert_eq!(unsafe { (*MEMO).get() }, 5);