Incular Docs

Memo<T> caches a derived value. Recomputes when dependencies change but propagates only when the result differs (T: PartialEq).

Method	Effect
`new(compute)`	Lazy derivation, unevaluated until read
`get()`	Tracked read, clones
`get_untracked()`	Read without subscribing
`with(f)` / `with_untracked(f)`	By-ref reads

use incular::prelude::*;
use incular::reactive::Memo;

fn main() {
    let count = Signal::new(2u32);
    let doubled = Memo::new({
        let count = count.clone();
        move || count.get() * 2
    });
    let app = Application::new(move |_cx| {
        Container::builder()
            .padding(EdgeInsets::all(24.0))
            .alignment(Alignment::CENTER)
            .child(Text::new(format!("Double: {}", doubled.get())))
            .build()
            .into()
    })
    .expect("valid application");
    incular::run(app).expect("run application");
}

Not evaluated until first read. Panics on dependency cycles ("reactive memo dependency cycle").

Inside a build, read with doubled.get() as the runnable program above does.

Related: Signal, Effect.