Struct leptos_reactive::signal_prelude::prelude::Memo

pub struct Memo<T>where
    T: 'static,{ /* private fields */ }

An efficient derived reactive value based on other reactive values.

Unlike a “derived signal,” a memo comes with two guarantees:

1. The memo will only run once per change, no matter how many times you access its value.
2. The memo will only notify its dependents if the value of the computation changes.

This makes a memo the perfect tool for expensive computations.

Memos have a certain overhead compared to derived signals. In most cases, you should create a derived signal. But if the derivation calculation is expensive, you should create a memo.

As with create_effect, the argument to the memo function is the previous value, i.e., the current value of the memo, which will be None for the initial calculation.

Core Trait Implementations

• .get() (or calling the signal as a function) clones the current value of the signal. If you call it within an effect, it will cause that effect to subscribe to the signal, and to re-run whenever the value of the signal changes.
  • .get_untracked() clones the value of the signal without reactively tracking it.
• .with() allows you to reactively access the signal’s value without cloning by applying a callback function.
  • .with_untracked() allows you to access the signal’s value without reactively tracking it.
• .to_stream() converts the signal to an async stream of values.

Examples

let (value, set_value) = create_signal(cx, 0);

// 🆗 we could create a derived signal with a simple function
let double_value = move || value() * 2;
set_value(2);
assert_eq!(double_value(), 4);

// but imagine the computation is really expensive
let expensive = move || really_expensive_computation(value()); // lazy: doesn't run until called
create_effect(cx, move |_| {
  // 🆗 run #1: calls `really_expensive_computation` the first time
  log::debug!("expensive = {}", expensive());
});
create_effect(cx, move |_| {
  // ❌ run #2: this calls `really_expensive_computation` a second time!
  let value = expensive();
  // do something else...
});

// instead, we create a memo
// 🆗 run #1: the calculation runs once immediately
let memoized = create_memo(cx, move |_| really_expensive_computation(value()));
create_effect(cx, move |_| {
 // 🆗 reads the current value of the memo
  log::debug!("memoized = {}", memoized());
});
create_effect(cx, move |_| {
  // ✅ reads the current value **without re-running the calculation**
  let value = memoized();
  // do something else...
});

Trait Implementations

impl<T> Clone for Memo<T>where T: 'static,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Memo<T>where T: 'static + Debug,

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

Formats the value using the given formatter.

impl<T> From<Memo<T>> for MaybeSignal<T>

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

Converts to this type from the input type.

impl<T> From<Memo<T>> for Signal<T>

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

Converts to this type from the input type.

impl<T> PartialEq<Memo<T>> for Memo<T>where T: 'static + PartialEq,

fn eq(&self, other: &Memo<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> SignalDispose for Memo<T>

fn dispose(self)

Disposes of the signal. This:

impl<T: Clone> SignalGet<T> for Memo<T>

Examples

let (count, set_count) = create_signal(cx, 0);
let double_count = create_memo(cx, move |_| count() * 2);

assert_eq!(double_count.get(), 0);
set_count(1);

// double_count() is shorthand for double_count.get()
assert_eq!(double_count(), 2);

fn get(&self) -> T

Clones and returns the current value of the signal, and subscribes the running effect to this signal.

fn try_get(&self) -> Option<T>

Clones and returns the signal value, returning Some if the signal is still alive, and None otherwise.

impl<T: Clone> SignalGetUntracked<T> for Memo<T>

fn get_untracked(&self) -> T

Gets the signal’s value without creating a dependency on the current scope.

fn try_get_untracked(&self) -> Option<T>

Gets the signal’s value without creating a dependency on the current scope. Returns [Some(T)] if the signal is still valid, None otherwise.

impl<T: Clone> SignalStream<T> for Memo<T>

fn to_stream(&self, cx: Scope) -> Pin<Box<dyn Stream<Item = T>>>

Generates a Stream that emits the new value of the signal whenever it changes.

impl<T> SignalWith<T> for Memo<T>

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

Applies a function to the current value of the signal, and subscribes the running effect to this signal.

fn try_with<O>(&self, f: impl FnOnce(&T) -> O) -> Option<O>

Applies a function to the current value of the signal, and subscribes the running effect to this signal. Returns Some if the signal is valid and the function ran, otherwise returns None.

fn track(&self)

Subscribes to this signal in the current reactive scope without doing anything with its value.

impl<T> SignalWithUntracked<T> for Memo<T>

fn with_untracked<O>(&self, f: impl FnOnce(&T) -> O) -> O

Runs the provided closure with a reference to the current value without creating a dependency on the current scope.

fn try_with_untracked<O>(&self, f: impl FnOnce(&T) -> O) -> Option<O>

Runs the provided closure with a reference to the current value without creating a dependency on the current scope. Returns [Some(O)] if the signal is still valid, None otherwise.

impl<T> Copy for Memo<T>

impl<T> Eq for Memo<T>where T: 'static + Eq,

impl<T> StructuralEq for Memo<T>where T: 'static,

impl<T> StructuralPartialEq for Memo<T>where T: 'static,