Struct Memo 

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

Equality/comparator-aware computed node.

Like Thunk, but a recomputation that produces an unchanged value (under PartialEq for memo, or a custom comparator for memo_by) does not invalidate downstream observers. Effects depending only on unchanged memos skip their re-runs entirely.

Clones share the same underlying node.

If the compute closure panics, the panic propagates to the reader and the node stays dirty, so the next read retries the computation.

Panics

Reading a memo whose computation (transitively) reads itself panics with a crate::ReactCycleError message describing the cycle path. To fold the memo’s own previous value into the next one, use memo_with_prev.

Implementations

impl<T: 'static> Memo<T>

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

Runs f with a shared reference to the current computed value.

Panics

Panics with a crate::ReactCycleError message when this memo’s computation (transitively) reads itself (use memo_with_prev for access to the previous value). A shared borrow of the cached value is held while f runs, so invalidating this memo and reading it again from inside f also panics.

impl<T: 'static> Memo<T>

pub fn reactor(&self) -> Reactor

Returns the reactor this memo’s node belongs to.

pub fn id(&self) -> NodeId

Returns this memo’s node id, for use with the graph queries on Reactor — observer_count, dependencies_of, node_origin and friends. Ids are unique within one reactor, so aggregate on (Reactor::id, id).

pub fn with_peek<R>(&self, f: impl FnOnce(&T) -> R) -> R

Runs f with a shared reference to the current computed value without recording a dependency. The memo is still brought up to date before f runs.

Panics

Panics under the same conditions as with.

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

pub fn get(&self) -> T

Clones and returns the current computed value.

pub fn peek(&self) -> T

Clones and returns the current computed value without recording a dependency.

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.

impl<T> Debug for Memo<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: 'static> Observable for Memo<T>

type Item = T

The type of value this observable holds.

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

Runs f with a shared reference to the current value, recording a dependency for the currently running observer.

fn with_peek<R>(&self, f: impl FnOnce(&T) -> R) -> R

Runs f with a shared reference to the current value without recording a dependency.

fn reactor(&self) -> Option<Reactor>

Returns the reactor this observable’s node belongs to, when it has one.

fn get(&self) -> Self::Item

where Self::Item: Clone,

Clones and returns the current value, recording a dependency.

fn peek(&self) -> Self::Item

where Self::Item: Clone,

Clones and returns the current value without recording a dependency.

fn map<U, F>(&self, f: F) -> Memo<U>

where Self: Clone + Sized + 'static, U: PartialEq + 'static, F: Fn(&Self::Item) -> U + 'static,

Derives a memo from this observable, cloning the receiver’s handle internally.

fn into_dyn(self) -> DynObservable<Self::Item>

where Self: Sized + 'static,

Erases this observable’s concrete type behind a cheaply-cloneable handle.