Struct Memo 

pub struct Memo<T: PartialEq + 'static> { /* private fields */ }

A memoized derived value that only recomputes when one of its tracked dependencies changes, and only notifies dependents when its value changes.

Unlike the previous implementation, this is driven by dependency invalidation rather than an Effect that eagerly recomputes.

Implementations

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

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

Trait Implementations

impl<T: Add<Output = T> + 'static + PartialEq> Add<T> for Memo<T>

where for<'a> &'a T: Add<T, Output = T>,

type Output = T

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<T: BitAnd<Output = T> + 'static + PartialEq> BitAnd<T> for Memo<T>

where for<'a> &'a T: BitAnd<T, Output = T>,

type Output = T

The resulting type after applying the & operator.

fn bitand(self, rhs: T) -> Self::Output

Performs the & operation.

impl<T: BitOr<Output = T> + 'static + PartialEq> BitOr<T> for Memo<T>

where for<'a> &'a T: BitOr<T, Output = T>,

type Output = T

The resulting type after applying the | operator.

fn bitor(self, rhs: T) -> Self::Output

Performs the | operation.

impl<T: BitXor<Output = T> + 'static + PartialEq> BitXor<T> for Memo<T>

where for<'a> &'a T: BitXor<T, Output = T>,

type Output = T

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: T) -> Self::Output

Performs the ^ operation.

impl<T: PartialEq + 'static> 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: Display + 'static + PartialEq> Display for Memo<T>

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

Formats the value using the given formatter.

impl<T: Div<Output = T> + 'static + PartialEq> Div<T> for Memo<T>

where for<'a> &'a T: Div<T, Output = T>,

type Output = T

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<T: Mul<Output = T> + 'static + PartialEq> Mul<T> for Memo<T>

where for<'a> &'a T: Mul<T, Output = T>,

type Output = T

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T: 'static + PartialEq> Neg for Memo<T>

where for<'a> &'a T: Neg<Output = T>,

type Output = T

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: 'static + PartialEq> Not for Memo<T>

where for<'a> &'a T: Not<Output = T>,

type Output = T

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

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

fn eq(&self, other: &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: Rem<Output = T> + 'static + PartialEq> Rem<T> for Memo<T>

where for<'a> &'a T: Rem<T, Output = T>,

type Output = T

The resulting type after applying the % operator.

fn rem(self, rhs: T) -> Self::Output

Performs the % operation.

impl<T: Shl<Output = T> + 'static + PartialEq> Shl<T> for Memo<T>

where for<'a> &'a T: Shl<T, Output = T>,

type Output = T

The resulting type after applying the << operator.

fn shl(self, rhs: T) -> Self::Output

Performs the << operation.

impl<T: Shr<Output = T> + 'static + PartialEq> Shr<T> for Memo<T>

where for<'a> &'a T: Shr<T, Output = T>,

type Output = T

The resulting type after applying the >> operator.

fn shr(self, rhs: T) -> Self::Output

Performs the >> operation.

impl<T: Clone + PartialEq + 'static> SignalGet<T> for Memo<T>

where ReadSignal<T>: SignalGet<T>,

fn id(&self) -> Id

get the Signal Id

fn get_untracked(&self) -> T

where T: 'static,

fn get(&self) -> T

where T: 'static,

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

where T: 'static,

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

where T: 'static,

impl<T: PartialEq + 'static> SignalTrack<T> for Memo<T>

fn id(&self) -> Id

fn track(&self)

Only subscribes to the current running effect to this Signal.

fn try_track(&self)

If the signal isn’t disposed,

impl<T: PartialEq + 'static> SignalWith<T> for Memo<T>

where ReadSignal<T>: SignalWith<T>,

fn id(&self) -> Id

get the Signal Id

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

where T: 'static,

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

where T: 'static,

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

where T: 'static,

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

where T: 'static,

impl<T: Sub<Output = T> + 'static + PartialEq> Sub<T> for Memo<T>

where for<'a> &'a T: Sub<T, Output = T>,

type Output = T

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<T: PartialEq + 'static> Copy for Memo<T>