Struct ArcMemo 

pub struct ArcMemo<T, S = SyncStorage>
where
    S: Storage<T>,
{ /* private fields */ }

An efficient derived reactive value based on other reactive values.

This is a reference-counted memo, which is Clone but not Copy. For arena-allocated Copy memos, use Memo.

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 an 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.

Examples

let (value, set_value) = signal(0);

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

// but imagine the computation is really expensive
let expensive = move || really_expensive_computation(value.get()); // lazy: doesn't run until called
// 🆗 run #1: calls `really_expensive_computation` the first time
println!("expensive = {}", expensive());
// ❌ run #2: this calls `really_expensive_computation` a second time!
let some_value = expensive();

// instead, we create a memo
// 🆗 run #1: the calculation runs once immediately
let memoized = ArcMemo::new(move |_| really_expensive_computation(value.get()));
// 🆗 reads the current value of the memo
//    can be `memoized()` on nightly
println!("memoized = {}", memoized.get());
// ✅ reads the current value **without re-running the calculation**
let some_value = memoized.get();

Core Trait Implementations

• .get() clones the current value of the memo. If you call it within an effect, it will cause that effect to subscribe to the memo, and to re-run whenever the value of the memo changes.
  • .get_untracked() clones the value of the memo without reactively tracking it.
• .read() returns a guard that allows accessing the value of the memo by reference. If you call it within an effect, it will cause that effect to subscribe to the memo, and to re-run whenever the value of the memo changes.
  • .read_untracked() gives access to the current value of the memo without reactively tracking it.
• .with() allows you to reactively access the memo’s value without cloning by applying a callback function.
  • .with_untracked() allows you to access the memo’s value by applying a callback function without reactively tracking it.
• .to_stream() converts the memo to an async stream of values.
• ::from_stream() converts an async stream of values into a memo containing the latest value.

Implementations

impl<T: 'static> ArcMemo<T, SyncStorage>

where SyncStorage: Storage<T>,

pub fn new(fun: impl Fn(Option<&T>) -> T + Send + Sync + 'static) -> Self

where T: PartialEq,

Creates a new memo by passing a function that computes the value.

This is lazy: the function will not be called until the memo’s value is read for the first time.

pub fn new_with_compare( fun: impl Fn(Option<&T>) -> T + Send + Sync + 'static, changed: fn(Option<&T>, Option<&T>) -> bool, ) -> Self

Creates a new memo by passing a function that computes the value, and a comparison function that takes the previous value and the new value and returns true if the value has changed.

This is lazy: the function will not be called until the memo’s value is read for the first time.

pub fn new_owning( fun: impl Fn(Option<T>) -> (T, bool) + Send + Sync + 'static, ) -> Self

Creates a new memo by passing a function that computes the value.

Unlike ArcMemo::new, this receives ownership of the previous value. As a result, it must return both the new value and a bool that is true if the value has changed.

This is lazy: the function will not be called until the memo’s value is read for the first time.

Trait Implementations

impl<T, S> Clone for ArcMemo<T, S>

where S: Storage<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, S> Debug for ArcMemo<T, S>

where S: Storage<T>,

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

Formats the value using the given formatter.

impl<T, S> DefinedAt for ArcMemo<T, S>

where S: Storage<T>,

fn defined_at(&self) -> Option<&'static Location<'static>>

Returns the location at which the signal was defined. This is usually simply None in release mode.

impl<T, S> Fn() for ArcMemo<T, S>

where ArcMemo<T, S>: Get, S: Storage<T> + Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>>,

Available on crate feature nightly only.

extern "rust-call" fn call(&self, _args: ()) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)

Performs the call operation.

impl<T, S> FnMut() for ArcMemo<T, S>

where ArcMemo<T, S>: Get, S: Storage<T> + Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>>,

Available on crate feature nightly only.

extern "rust-call" fn call_mut(&mut self, _args: ()) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)

Performs the call operation.

impl<T, S> FnOnce() for ArcMemo<T, S>

where ArcMemo<T, S>: Get, S: Storage<T> + Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>>,

Available on crate feature nightly only.

type Output = <ArcMemo<T, S> as Get>::Value

The returned type after the call operator is used.

extern "rust-call" fn call_once(self, _args: ()) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)

Performs the call operation.

impl<T> From<ArcMemo<T>> for MaybeSignal<T>

where T: Send + Sync,

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

Converts to this type from the input type.

impl<T> From<ArcMemo<T>> for Memo<T>

where T: Send + Sync + 'static,

fn from(value: ArcMemo<T, SyncStorage>) -> Self

Converts to this type from the input type.

impl<T> From<ArcMemo<T>> for Signal<T>

where T: Send + Sync + 'static,

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

Converts to this type from the input type.

impl<T> From<ArcMemo<T, LocalStorage>> for Signal<T, LocalStorage>

where T: Send + Sync + 'static,

fn from(value: ArcMemo<T, LocalStorage>) -> Self

Converts to this type from the input type.

impl<T, S> From<ArcMemo<T, S>> for ArcSignal<T, S>

where S: Storage<T>,

fn from(value: ArcMemo<T, S>) -> Self

Converts to this type from the input type.

impl<T> From<ArcReadSignal<T>> for ArcMemo<T, SyncStorage>

where T: Clone + PartialEq + Send + Sync + 'static,

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

Converts to this type from the input type.

impl<T> From<ArcRwSignal<T>> for ArcMemo<T, SyncStorage>

where T: Clone + PartialEq + Send + Sync + 'static,

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

Converts to this type from the input type.

impl<T, S> From<Memo<T, S>> for ArcMemo<T, S>

where T: 'static, S: Storage<ArcMemo<T, S>> + Storage<T>,

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

Converts to this type from the input type.

impl<T> FromLocal<ArcMemo<T, LocalStorage>> for MaybeSignal<T, LocalStorage>

fn from_local(value: ArcMemo<T, LocalStorage>) -> Self

Converts between the types.

impl<T> FromLocal<ArcMemo<T, LocalStorage>> for Memo<T, LocalStorage>

where T: 'static,

fn from_local(value: ArcMemo<T, LocalStorage>) -> Self

Converts between the types.

impl<T, S> Hash for ArcMemo<T, S>

where S: Storage<T>,

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: 'static, S> IsDisposed for ArcMemo<T, S>

where S: Storage<T>,

fn is_disposed(&self) -> bool

If true, the signal cannot be accessed without a panic.

impl<T, S> PartialEq for ArcMemo<T, S>

where S: Storage<T>,

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T: 'static, S> ReactiveNode for ArcMemo<T, S>

where S: Storage<T>,

fn mark_dirty(&self)

Notifies the source’s dependencies that it has changed.

fn mark_check(&self)

Notifies the source’s dependencies that it may have changed.

fn mark_subscribers_check(&self)

Marks that all subscribers need to be checked.

fn update_if_necessary(&self) -> bool

Regenerates the value for this node, if needed, and returns whether it has actually changed or not.

impl<T: 'static, S> ReadUntracked for ArcMemo<T, S>

where S: Storage<T>,

type Value = ReadGuard<T, Mapped<Plain<Option<<S as Storage<T>>::Wrapped>>, T>>

The guard type that will be returned, which can be dereferenced to the value.

fn try_read_untracked(&self) -> Option<Self::Value>

Returns the guard, or None if the signal has already been disposed.

fn read_untracked(&self) -> Self::Value

Returns the guard.

fn custom_try_read(&self) -> Option<Option<Self::Value>>

This is a backdoor to allow overriding the Read::try_read implementation despite it being auto implemented.

impl<T: Serialize + 'static, St: Storage<T>> Serialize for ArcMemo<T, St>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: 'static, S> Source for ArcMemo<T, S>

where S: Storage<T>,

fn add_subscriber(&self, subscriber: AnySubscriber)

Adds a subscriber to this source’s list of dependencies.

fn remove_subscriber(&self, subscriber: &AnySubscriber)

Removes a subscriber from this source’s list of dependencies.

fn clear_subscribers(&self)

Remove all subscribers from this source’s list of dependencies.

impl<T: 'static, S> Subscriber for ArcMemo<T, S>

where S: Storage<T>,

fn add_source(&self, source: AnySource)

Adds a subscriber to this subscriber’s list of dependencies.

fn clear_sources(&self, subscriber: &AnySubscriber)

Clears the set of sources for this subscriber.

impl<T: 'static, S> ToAnySource for ArcMemo<T, S>

where S: Storage<T>,

fn to_any_source(&self) -> AnySource

Converts this type to its type-erased equivalent.

impl<T: 'static, S> ToAnySubscriber for ArcMemo<T, S>

where S: Storage<T>,

fn to_any_subscriber(&self) -> AnySubscriber

Converts this type to its type-erased equivalent.

impl<T, S> Eq for ArcMemo<T, S>

where S: Storage<T>,