Struct Memo 

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

Handle to a memoized value created by Context::use_memo.

Like State<T>, this is an index handle, not a live borrow — it stores only the hook slot index and does not keep Context borrowed. That is the whole point: the handle composes with later ui.* calls, where the old &T-returning form (now Context::use_memo_ref) held an immutable borrow of ui that conflicted with any subsequent mutation.

Read the value with get (&T) or copied (T: Copy).

Example

let count = ui.use_state(|| 0i32);
let count_val = *count.get(ui);
// Handle releases the `&mut ui` borrow immediately...
let doubled = ui.use_memo(&count_val, |c| c * 2);
// ...so an intervening `ui.*` call composes cleanly.
ui.text("computed:");
ui.text(format!("{}", doubled.copied(ui)));

Implementations

impl<T: 'static> Memo<T>

pub fn get<'a>(&self, ui: &'a Context) -> &'a T

Read the memoized value.

Panics

Panics with the slot index and expected type name if the hook at this index does not hold a MemoSlot<T> — i.e. the rules-of-hooks contract was broken (hooks called in a different order than the frame that created the slot). The message matches Context::use_memo’s own mismatch panic.

Example

let m = ui.use_memo(&3i32, |d| d * 2);
ui.text(format!("{}", m.get(ui)));

pub fn copied(&self, ui: &Context) -> T

where T: Copy,

Read a Copy of the memoized value.

Convenience for *memo.get(ui). Panics under the same conditions as get.

Example

let doubled = ui.use_memo(&21i32, |d| d * 2).copied(ui);
ui.text(format!("{doubled}"));

Trait Implementations

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Memo<T>

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

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for Memo<T>

fn eq(&self, other: &Memo<T>) -> 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: Eq> Eq for Memo<T>

impl<T> StructuralPartialEq for Memo<T>