Trait Diff

pub trait Diff: Copy {
    type Memo: 'static;

    // Required methods
    fn into_memo(self) -> Self::Memo;
    fn diff(self, memo: &mut Self::Memo) -> bool;
}

Trait that defines how different values can be diffed at runtime.

Required Associated Types

type Memo: 'static

Data used to check if current value is different from the one in the past.

Required Methods

fn into_memo(self) -> Self::Memo

Generate a new Memo for this type.

fn diff(self, memo: &mut Self::Memo) -> bool

Diff current value against the Memo, update it if necessary and return true if it has changed.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Diff for &str

type Memo = String

fn into_memo(self) -> String

fn diff(self, memo: &mut String) -> bool

impl Diff for &String

type Memo = String

fn into_memo(self) -> String

fn diff(self, memo: &mut String) -> bool

impl Diff for bool

type Memo = bool

fn into_memo(self) -> bool

fn diff(self, memo: &mut bool) -> bool

impl Diff for f32

type Memo = f32

fn into_memo(self) -> f32

fn diff(self, memo: &mut f32) -> bool

impl Diff for f64

type Memo = f64

fn into_memo(self) -> f64

fn diff(self, memo: &mut f64) -> bool

impl Diff for i8

type Memo = i8

fn into_memo(self) -> i8

fn diff(self, memo: &mut i8) -> bool

impl Diff for i16

type Memo = i16

fn into_memo(self) -> i16

fn diff(self, memo: &mut i16) -> bool

impl Diff for i32

type Memo = i32

fn into_memo(self) -> i32

fn diff(self, memo: &mut i32) -> bool

impl Diff for i64

type Memo = i64

fn into_memo(self) -> i64

fn diff(self, memo: &mut i64) -> bool

impl Diff for i128

type Memo = i128

fn into_memo(self) -> i128

fn diff(self, memo: &mut i128) -> bool

impl Diff for isize

type Memo = isize

fn into_memo(self) -> isize

fn diff(self, memo: &mut isize) -> bool

impl Diff for u8

type Memo = u8

fn into_memo(self) -> u8

fn diff(self, memo: &mut u8) -> bool

impl Diff for u16

type Memo = u16

fn into_memo(self) -> u16

fn diff(self, memo: &mut u16) -> bool

impl Diff for u32

type Memo = u32

fn into_memo(self) -> u32

fn diff(self, memo: &mut u32) -> bool

impl Diff for u64

type Memo = u64

fn into_memo(self) -> u64

fn diff(self, memo: &mut u64) -> bool

impl Diff for u128

type Memo = u128

fn into_memo(self) -> u128

fn diff(self, memo: &mut u128) -> bool

impl Diff for usize

type Memo = usize

fn into_memo(self) -> usize

fn diff(self, memo: &mut usize) -> bool

Implementors

impl Diff for &VString

type Memo = u64

impl<T> Diff for Eager<T>

where T: Copy,

type Memo = ()

impl<T> Diff for Static<T>

where T: Copy,

type Memo = ()

impl<T: ?Sized> Diff for &Ref<T>

type Memo = *const ()