Struct Memo 

pub struct Memo<T>
where
    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> Memo<T>

where T: PartialEq + 'static,

Create a Memo which takes the computed value of the given function, and triggers the reactive system when the computed value is different from the last computed value.

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

Trait Implementations

impl<T> Add<T> for Memo<T>

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

type Output = T

The resulting type after applying the + operator.

fn add(self, rhs: T) -> <Memo<T> as Add<T>>::Output

Performs the + operation.

impl<T> BitAnd<T> for Memo<T>

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

type Output = T

The resulting type after applying the & operator.

fn bitand(self, rhs: T) -> <Memo<T> as BitAnd<T>>::Output

Performs the & operation.

impl<T> BitOr<T> for Memo<T>

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

type Output = T

The resulting type after applying the | operator.

fn bitor(self, rhs: T) -> <Memo<T> as BitOr<T>>::Output

Performs the | operation.

impl<T> BitXor<T> for Memo<T>

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

type Output = T

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: T) -> <Memo<T> as BitXor<T>>::Output

Performs the ^ operation.

impl<T> Clone for Memo<T>

where T: PartialEq + 'static,

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

where T: Display + 'static + PartialEq,

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

Formats the value using the given formatter.

impl<T> Div<T> for Memo<T>

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

type Output = T

The resulting type after applying the / operator.

fn div(self, rhs: T) -> <Memo<T> as Div<T>>::Output

Performs the / operation.

impl<T> Mul<T> for Memo<T>

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

type Output = T

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> <Memo<T> as Mul<T>>::Output

Performs the * operation.

impl<T> Neg for Memo<T>

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

type Output = T

The resulting type after applying the - operator.

fn neg(self) -> <Memo<T> as Neg>::Output

Performs the unary - operation.

impl<T> Not for Memo<T>

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

type Output = T

The resulting type after applying the ! operator.

fn not(self) -> <Memo<T> as Not>::Output

Performs the unary ! operation.

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

where T: PartialEq + 'static,

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

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

type Output = T

The resulting type after applying the % operator.

fn rem(self, rhs: T) -> <Memo<T> as Rem<T>>::Output

Performs the % operation.

impl<T> Res<T> for Memo<T>

where T: Clone + PartialEq + 'static,

fn get_value(&self, _: &impl DataContext) -> T

Returns the value of a resource by value.

fn set_or_bind<F>(self, cx: &mut Context, closure: F)

where F: 'static + Fn(&mut Context, Memo<T>),

fn to_signal(self, cx: &mut Context) -> Signal<T>

where Self: Sized + 'static, T: Clone + 'static,

Converts this signal into a signal mirror tied to entity.

impl<T> Shl<T> for Memo<T>

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

type Output = T

The resulting type after applying the << operator.

fn shl(self, rhs: T) -> <Memo<T> as Shl<T>>::Output

Performs the << operation.

impl<T> Shr<T> for Memo<T>

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

type Output = T

The resulting type after applying the >> operator.

fn shr(self, rhs: T) -> <Memo<T> as Shr<T>>::Output

Performs the >> operation.

impl<T> SignalGet<T> for Memo<T>

where T: Clone + PartialEq + 'static, 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> SignalTrack<T> for Memo<T>

where T: PartialEq + 'static,

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

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

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

type Output = T

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> <Memo<T> as Sub<T>>::Output

Performs the - operation.

impl<T> Copy for Memo<T>

where T: PartialEq + 'static,