Struct Memo 

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

A memo is 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.

Memos are lazy: they do not run at all until they are read for the first time, and they will not re-run the calculation when a source signal changes until they are read again.

This is an arena-allocated type, which is Copy and is disposed when its reactive Owner cleans up. For a reference-counted signal that livesas as long as a reference to it is alive, see ArcMemo.

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
Effect::new(move |_| {
  // 🆗 run #1: calls `really_expensive_computation` the first time
  println!("expensive = {}", expensive());
});
Effect::new(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 = Memo::new(move |_| really_expensive_computation(value.get()));
Effect::new(move |_| {
  // 🆗 reads the current value of the memo
  //    can be `memoized()` on nightly
  println!("memoized = {}", memoized.get());
});
Effect::new(move |_| {
  // ✅ reads the current value **without re-running the calculation**
  let value = memoized.get();
  // do something else...
});

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> Memo<T>

where T: Send + Sync + 'static,

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

where T: PartialEq,

Creates a new memoized, computed reactive value.

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.

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

// the memo will reactively update whenever `value` changes
let memoized =
    Memo::new(move |_| really_expensive_computation(value.get()));

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

Creates a new memo with a custom comparison function. By default, memos simply use PartialEq to compare the previous value to the new value. Passing a custom comparator allows you to compare the old and new values using any criteria.

changed should be a function that returns true if the new value is different from the old value.

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

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

Unlike Memo::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<V, S> AddAnyAttr for Memo<V, S>

where Memo<V, S>: Get<Value = V>, S: Send + Sync + 'static + Storage<V> + Storage<Option<V>>, V: RenderHtml + Clone + Send + Sync + 'static, <V as Render>::State: 'static,

type Output<SomeNewAttr: Attribute> = Memo<V, S>

The new type once the attribute has been added.

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <Memo<V, S> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <Memo<V, S> as AddAnyAttr>::Output<NewAttr>: RenderHtml,

Adds an attribute to the view.

impl<V, S> AttributeValue for Memo<V, S>

where Memo<V, S>: Get<Value = V>, S: Storage<V> + Storage<Option<V>> + Send + Sync + 'static, V: AttributeValue + Send + Sync + Clone + 'static, <V as AttributeValue>::State: 'static,

type AsyncOutput = Memo<V, S>

The type once all async data have loaded.

type State = RenderEffect<<V as AttributeValue>::State>

The state that should be retained between building and rebuilding.

type Cloneable = Memo<V, S>

A version of the value that can be cloned. This can be the same type, or a reference-counted type. Generally speaking, this does not need to refer to the same data, but should behave in the same way. So for example, making an event handler cloneable should probably make it reference-counted (so that a FnMut() continues mutating the same closure), but making a String cloneable does not necessarily need to make it an Arc<str>, as two different clones of a String will still have the same value.

type CloneableOwned = Memo<V, S>

A cloneable type that is also 'static. This is used for spreading across types when the spreadable attribute needs to be owned. In some cases (&'a str to Arc<str>, etc.) the owned cloneable type has worse performance than the cloneable type, so they are separate.

fn html_len(&self) -> usize

An approximation of the actual length of this attribute in HTML.

fn to_html(self, key: &str, buf: &mut String)

Renders the attribute value to HTML.

fn to_template(_key: &str, _buf: &mut String)

Renders the attribute value to HTML for a <template>.

fn hydrate<const FROM_SERVER: bool>( self, key: &str, el: &Element, ) -> <Memo<V, S> as AttributeValue>::State

Adds interactivity as necessary, given DOM nodes that were created from HTML that has either been rendered on the server, or cloned for a <template>.

fn build(self, el: &Element, key: &str) -> <Memo<V, S> as AttributeValue>::State

Adds this attribute to the element during client-side rendering.

fn rebuild(self, key: &str, state: &mut <Memo<V, S> as AttributeValue>::State)

Applies a new value for the attribute.

fn into_cloneable(self) -> <Memo<V, S> as AttributeValue>::Cloneable

Converts this attribute into an equivalent that can be cloned.

fn into_cloneable_owned(self) -> <Memo<V, S> as AttributeValue>::CloneableOwned

Converts this attributes into an equivalent that can be cloned and is 'static.

fn dry_resolve(&mut self)

“Runs” the attribute without other side effects. For primitive types, this is a no-op. For reactive types, this can be used to gather data about reactivity or about asynchronous data that needs to be loaded.

async fn resolve(self) -> <Memo<V, S> as AttributeValue>::AsyncOutput

“Resolves” this into a form that is not waiting for any asynchronous data.

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

where S: Storage<T>,

fn clone(&self) -> Memo<T, S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, S> Copy for Memo<T, S>

where S: Storage<T>,

impl<T, S> Debug for Memo<T, S>

where S: Debug + Storage<T>,

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

Formats the value using the given formatter.

impl<T, S> DefinedAt for Memo<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> Dispose for Memo<T, S>

where S: Storage<T>,

fn dispose(self)

Disposes of the signal. This:

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

where S: Storage<T>,

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

where T: Send + Sync + 'static,

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

Converts to this type from the input type.

impl<T> From<ArcReadSignal<T>> for Memo<T>

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

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

Converts to this type from the input type.

impl<T> From<Memo<Option<T>, LocalStorage>> for MaybeProp<T, LocalStorage>

where T: Send + Sync,

fn from(value: Memo<Option<T>, LocalStorage>) -> MaybeProp<T, LocalStorage>

Converts to this type from the input type.

impl<T> From<Memo<Option<T>>> for MaybeProp<T>

where T: Send + Sync,

fn from(value: Memo<Option<T>>) -> MaybeProp<T>

Converts to this type from the input type.

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

where T: 'static,

fn from(value: Memo<T, LocalStorage>) -> Signal<T, LocalStorage>

Converts to this type from the input type.

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

fn from(value: Memo<T, LocalStorage>) -> MaybeSignal<T, LocalStorage>

Converts to this type from the input type.

impl<T> From<Memo<T, LocalStorage>> for MaybeProp<T, LocalStorage>

where T: Send + Sync + Clone,

fn from(value: Memo<T, LocalStorage>) -> MaybeProp<T, LocalStorage>

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>) -> ArcMemo<T, S>

Converts to this type from the input type.

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

where T: Send + Sync + 'static,

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

Converts to this type from the input type.

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

where T: Send + Sync,

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

Converts to this type from the input type.

impl<T> From<Memo<T>> for MaybeProp<T>

where T: Send + Sync + Clone,

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

Converts to this type from the input type.

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

where T: 'static,

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

Converts between the types.

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

where S: Storage<T>,

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

where H: Hasher,

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<V, S> InnerHtmlValue for Memo<V, S>

where Memo<V, S>: Get<Value = V>, S: Send + Sync + 'static + Storage<V>, V: InnerHtmlValue + Send + Sync + Clone + 'static, <V as InnerHtmlValue>::State: 'static,

type AsyncOutput = Memo<V, S>

The type after all async data have resolved.

type State = RenderEffect<<V as InnerHtmlValue>::State>

The view state retained between building and rebuilding.

type Cloneable = Memo<V, S>

An equivalent value that can be cloned.

type CloneableOwned = Memo<V, S>

An equivalent value that can be cloned and is 'static.

fn html_len(&self) -> usize

The estimated length of the HTML.

fn to_html(self, buf: &mut String)

Renders the class to HTML.

fn to_template(_buf: &mut String)

Renders the class to HTML for a <template>.

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, ) -> <Memo<V, S> as InnerHtmlValue>::State

Adds interactivity as necessary, given DOM nodes that were created from HTML that has either been rendered on the server, or cloned for a <template>.

fn build(self, el: &Element) -> <Memo<V, S> as InnerHtmlValue>::State

Adds this class to the element during client-side rendering.

fn rebuild(self, state: &mut <Memo<V, S> as InnerHtmlValue>::State)

Updates the value.

fn into_cloneable(self) -> <Memo<V, S> as InnerHtmlValue>::Cloneable

Converts this to a cloneable type.

fn into_cloneable_owned(self) -> <Memo<V, S> as InnerHtmlValue>::CloneableOwned

Converts this to a cloneable, owned type.

fn dry_resolve(&mut self)

“Runs” the attribute without other side effects. For primitive types, this is a no-op. For reactive types, this can be used to gather data about reactivity or about asynchronous data that needs to be loaded.

async fn resolve(self) -> <Memo<V, S> as InnerHtmlValue>::AsyncOutput

“Resolves” this into a type that is not waiting for any asynchronous data.

impl<C, S> IntoClass for Memo<C, S>

where Memo<C, S>: Get<Value = C>, S: Send + Sync + 'static + Storage<C> + Storage<Option<C>>, C: IntoClass + Send + Sync + Clone + 'static, <C as IntoClass>::State: 'static,

type AsyncOutput = Memo<C, S>

The type after all async data have resolved.

type State = RenderEffect<<C as IntoClass>::State>

The view state retained between building and rebuilding.

type Cloneable = Memo<C, S>

An equivalent value that can be cloned.

type CloneableOwned = Memo<C, S>

An equivalent value that can be cloned and is 'static.

fn html_len(&self) -> usize

The estimated length of the HTML.

fn to_html(self, class: &mut String)

Renders the class to HTML.

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, ) -> <Memo<C, S> as IntoClass>::State

Adds interactivity as necessary, given DOM nodes that were created from HTML that has either been rendered on the server, or cloned for a <template>.

fn build(self, el: &Element) -> <Memo<C, S> as IntoClass>::State

Adds this class to the element during client-side rendering.

fn rebuild(self, state: &mut <Memo<C, S> as IntoClass>::State)

Updates the value.

fn into_cloneable(self) -> <Memo<C, S> as IntoClass>::Cloneable

Converts this to a cloneable type.

fn into_cloneable_owned(self) -> <Memo<C, S> as IntoClass>::CloneableOwned

Converts this to a cloneable, owned type.

fn dry_resolve(&mut self)

“Runs” the attribute without other side effects. For primitive types, this is a no-op. For reactive types, this can be used to gather data about reactivity or about asynchronous data that needs to be loaded.

async fn resolve(self) -> <Memo<C, S> as IntoClass>::AsyncOutput

“Resolves” this into a type that is not waiting for any asynchronous data.

fn reset(state: &mut <Memo<C, S> as IntoClass>::State)

Reset the class list to the state before this class was added.

const TEMPLATE: &'static str = ""

The HTML that should be included in a <template>.

const MIN_LENGTH: usize = _

The minimum length of the HTML.

fn to_template(class: &mut String)

Renders the class to HTML for a <template>.

impl<V, S> IntoProperty for Memo<V, S>

where Memo<V, S>: Get<Value = V>, S: Send + Sync + 'static + Storage<V> + Storage<Option<V>>, V: IntoProperty + Send + Sync + Clone + 'static, <V as IntoProperty>::State: 'static,

type State = RenderEffect<<V as IntoProperty>::State>

The view state retained between building and rebuilding.

type Cloneable = Memo<V, S>

An equivalent value that can be cloned.

type CloneableOwned = Memo<V, S>

An equivalent value that can be cloned and is 'static.

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, key: &str, ) -> <Memo<V, S> as IntoProperty>::State

Adds the property on an element created from HTML.

fn build(self, el: &Element, key: &str) -> <Memo<V, S> as IntoProperty>::State

Adds the property during client-side rendering.

fn rebuild(self, state: &mut <Memo<V, S> as IntoProperty>::State, key: &str)

Updates the property with a new value.

fn into_cloneable(self) -> <Memo<V, S> as IntoProperty>::Cloneable

Converts this to a cloneable type.

fn into_cloneable_owned(self) -> <Memo<V, S> as IntoProperty>::CloneableOwned

Converts this to a cloneable, owned type.

impl<C, S> IntoStyle for Memo<C, S>

where Memo<C, S>: Get<Value = C>, S: Storage<C> + Storage<Option<C>> + Send + Sync + 'static, C: IntoStyle + Send + Sync + Clone + 'static, <C as IntoStyle>::State: 'static,

type AsyncOutput = Memo<C, S>

The type after all async data have resolved.

type State = RenderEffect<<C as IntoStyle>::State>

The view state retained between building and rebuilding.

type Cloneable = Memo<C, S>

An equivalent value that can be cloned.

type CloneableOwned = Memo<C, S>

An equivalent value that can be cloned and is 'static.

fn to_html(self, style: &mut String)

Renders the style to HTML.

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, ) -> <Memo<C, S> as IntoStyle>::State

Adds interactivity as necessary, given DOM nodes that were created from HTML that has either been rendered on the server, or cloned for a <template>.

fn build(self, el: &Element) -> <Memo<C, S> as IntoStyle>::State

Adds this style to the element during client-side rendering.

fn rebuild(self, state: &mut <Memo<C, S> as IntoStyle>::State)

Updates the value.

fn into_cloneable(self) -> <Memo<C, S> as IntoStyle>::Cloneable

Converts this to a cloneable type.

fn into_cloneable_owned(self) -> <Memo<C, S> as IntoStyle>::CloneableOwned

Converts this to a cloneable, owned type.

fn dry_resolve(&mut self)

“Runs” the attribute without other side effects. For primitive types, this is a no-op. For reactive types, this can be used to gather data about reactivity or about asynchronous data that needs to be loaded.

async fn resolve(self) -> <Memo<C, S> as IntoStyle>::AsyncOutput

“Resolves” this into a type that is not waiting for any asynchronous data.

fn reset(state: &mut <Memo<C, S> as IntoStyle>::State)

Reset the styling to the state before this style was added.

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

where S: Storage<T>,

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

Equality operator ==.

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

Inequality operator !=.

impl<T, S> ReadUntracked for Memo<T, S>

where T: 'static, S: Storage<ArcMemo<T, 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<<Memo<T, S> as ReadUntracked>::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<V, S> Render for Memo<V, S>

where Memo<V, S>: Get<Value = V>, S: Send + Sync + 'static + Storage<V> + Storage<Option<V>>, V: Render + Send + Sync + Clone + 'static, <V as Render>::State: 'static,

type State = RenderEffectState<<V as Render>::State>

The “view state” for this type, which can be retained between updates.

fn build(self) -> <Memo<V, S> as Render>::State

Creates the view for the first time, without hydrating from existing HTML.

fn rebuild(self, state: &mut <Memo<V, S> as Render>::State)

Updates the view with new data.

impl<V, S> RenderHtml for Memo<V, S>

where Memo<V, S>: Get<Value = V>, S: Send + Sync + 'static + Storage<V> + Storage<Option<V>>, V: RenderHtml + Clone + Send + Sync + 'static, <V as Render>::State: 'static,

const MIN_LENGTH: usize = 0

The minimum length of HTML created when this view is rendered.

type AsyncOutput = Memo<V, S>

The type of the view after waiting for all asynchronous data to load.

fn dry_resolve(&mut self)

“Runs” the view without other side effects. For primitive types, this is a no-op. For reactive types, this can be used to gather data about reactivity or about asynchronous data that needs to be loaded.

async fn resolve(self) -> <Memo<V, S> as RenderHtml>::AsyncOutput

Waits for any asynchronous sections of the view to load and returns the output.

fn html_len(&self) -> usize

An estimated length for this view, when rendered to HTML.

fn to_html_with_buf( self, buf: &mut String, position: &mut Position, escape: bool, mark_branches: bool, )

Renders a view to HTML, writing it into the given buffer.

fn to_html_async_with_buf<const OUT_OF_ORDER: bool>( self, buf: &mut StreamBuilder, position: &mut Position, escape: bool, mark_branches: bool, )

where Memo<V, S>: Sized,

Renders a view into a buffer of (synchronous or asynchronous) HTML chunks.

fn hydrate<const FROM_SERVER: bool>( self, cursor: &Cursor, position: &PositionState, ) -> <Memo<V, S> as Render>::State

Makes a set of DOM nodes rendered from HTML interactive.

const EXISTS: bool = true

Whether this should actually exist in the DOM, if it is the child of an element.

fn to_html(self) -> String

where Self: Sized,

Renders a view to an HTML string.

fn to_html_branching(self) -> String

where Self: Sized,

Renders a view to HTML with branch markers. This can be used to support libraries that diff HTML pages against one another, by marking sections of the view that branch to different types with marker comments.

fn to_html_stream_in_order(self) -> StreamBuilder

where Self: Sized,

Renders a view to an in-order stream of HTML.

fn to_html_stream_in_order_branching(self) -> StreamBuilder

where Self: Sized,

Renders a view to an in-order stream of HTML with branch markers. This can be used to support libraries that diff HTML pages against one another, by marking sections of the view that branch to different types with marker comments.

fn to_html_stream_out_of_order(self) -> StreamBuilder

where Self: Sized,

Renders a view to an out-of-order stream of HTML.

fn to_html_stream_out_of_order_branching(self) -> StreamBuilder

where Self: Sized,

Renders a view to an out-of-order stream of HTML with branch markers. This can be used to support libraries that diff HTML pages against one another, by marking sections of the view that branch to different types with marker comments.

fn hydrate_from<const FROM_SERVER: bool>(self, el: &Element) -> Self::State

where Self: Sized,

Hydrates using RenderHtml::hydrate, beginning at the given element.

fn hydrate_from_position<const FROM_SERVER: bool>( self, el: &Element, position: Position, ) -> Self::State

where Self: Sized,

Hydrates using RenderHtml::hydrate, beginning at the given element and position.

impl<T, St> Serialize for Memo<T, St>

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

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T, S> Track for Memo<T, S>

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

fn track(&self)

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