Trait diff::Diff

pub trait Diff: Sized {
    type Repr;
    fn diff(&self, other: &Self) -> Self::Repr;
    fn apply(&mut self, diff: &Self::Repr);
    fn identity() -> Self;

    fn diff_custom<D: Differ<Self>>(&self, other: &Self, visitor: &D) -> D::Repr { ... }
    fn apply_custom<D: Differ<Self>>(&mut self, diff: &D::Repr, visitor: &D) { ... }
    fn apply_new(&self, diff: &Self::Repr) -> Self { ... }
    fn apply_new_custom<D: Differ<Self>>(
        &self, 
        diff: &D::Repr, 
        visitor: &D
    ) -> Self { ... }
}

A trait to diff and apply diffs between two structs The derive macro can be used on structs when all fields of the struct implement Diff Implementations are provided for bools, numeric types, Option types, and HashMaps

Associated Types

type Repr

The type associated with the structs' difference

Loading content...

Required methods

fn diff(&self, other: &Self) -> Self::Repr

Produces a diff between two structs

fn apply(&mut self, diff: &Self::Repr)

Applies the diff directly to the struct

fn identity() -> Self

The identity element of the struct

use diff::Diff;
let s = 42;
let i = <i32 as Diff>::identity();
assert_eq!(i.apply_new(&i.diff(&s)), s);

or mathematically speaking, i + (s - i) = s

Loading content...

Provided methods

fn diff_custom<D: Differ<Self>>(&self, other: &Self, visitor: &D) -> D::Repr

Produces a diff between two structs, using an external diffing implementation

fn apply_custom<D: Differ<Self>>(&mut self, diff: &D::Repr, visitor: &D)

Applies the diff directly to the struct, using an external diffing implementation

fn apply_new(&self, diff: &Self::Repr) -> Self

Applies the diff to the struct and produces a new struct

fn apply_new_custom<D: Differ<Self>>(&self, diff: &D::Repr, visitor: &D) -> Self

Applies the diff to the struct and produces a new struct, using an external diffing implementation

Loading content...

Implementations on Foreign Types

impl Diff for bool

type Repr = Option<bool>

fn diff(&self, other: &Self) -> Self::Repr

fn apply(&mut self, diff: &Self::Repr)

fn identity() -> Self

impl Diff for u8

type Repr = u8

fn diff(&self, other: &Self) -> Self::Repr

fn apply(&mut self, diff: &Self::Repr)

fn identity() -> u8

impl Diff for i8

type Repr = i8

fn diff(&self, other: &Self) -> Self::Repr

fn apply(&mut self, diff: &Self::Repr)

fn identity() -> i8

impl Diff for u16

type Repr = u16

fn diff(&self, other: &Self) -> Self::Repr

fn apply(&mut self, diff: &Self::Repr)

fn identity() -> u16

impl Diff for i16

type Repr = i16

fn diff(&self, other: &Self) -> Self::Repr

fn apply(&mut self, diff: &Self::Repr)

fn identity() -> i16

impl Diff for u32

type Repr = u32

fn diff(&self, other: &Self) -> Self::Repr

fn apply(&mut self, diff: &Self::Repr)

fn identity() -> u32

impl Diff for i32

type Repr = i32

fn diff(&self, other: &Self) -> Self::Repr

fn apply(&mut self, diff: &Self::Repr)

fn identity() -> i32

impl Diff for u64

type Repr = u64

fn diff(&self, other: &Self) -> Self::Repr

fn apply(&mut self, diff: &Self::Repr)

fn identity() -> u64

impl Diff for i64

type Repr = i64

fn diff(&self, other: &Self) -> Self::Repr

fn apply(&mut self, diff: &Self::Repr)

fn identity() -> i64

impl Diff for usize

type Repr = usize

fn diff(&self, other: &Self) -> Self::Repr

fn apply(&mut self, diff: &Self::Repr)

fn identity() -> usize

impl Diff for isize

type Repr = isize

fn diff(&self, other: &Self) -> Self::Repr

fn apply(&mut self, diff: &Self::Repr)

fn identity() -> isize

impl Diff for f32

type Repr = f32

fn diff(&self, other: &Self) -> Self::Repr

fn apply(&mut self, diff: &Self::Repr)

fn identity() -> f32

impl Diff for f64

type Repr = f64

fn diff(&self, other: &Self) -> Self::Repr

fn apply(&mut self, diff: &Self::Repr)

fn identity() -> f64

impl Diff for char

type Repr = Option<char>

fn diff(&self, other: &Self) -> Self::Repr

fn apply(&mut self, diff: &Self::Repr)

fn identity() -> Self

impl Diff for String

type Repr = Option<String>

fn diff(&self, other: &Self) -> Self::Repr

fn apply(&mut self, diff: &Self::Repr)

fn identity() -> Self

impl<T: Diff + PartialEq> Diff for Option<T>

type Repr = OptionDiff<T>

fn diff(&self, other: &Self) -> Self::Repr

fn apply(&mut self, diff: &Self::Repr)

fn identity() -> Self

impl<K: Hash + Eq, V: Diff> Diff for HashMap<K, V> where
    K: Clone,
    V: PartialEq, 

type Repr = HashMapDiff<K, V>

fn diff(&self, other: &Self) -> Self::Repr

fn apply(&mut self, diff: &Self::Repr)

fn identity() -> Self

impl<T: Diff + PartialEq> Diff for Vec<T>

type Repr = VecDiff<T>

fn diff(&self, other: &Self) -> Self::Repr

fn apply(&mut self, diff: &Self::Repr)

fn identity() -> Self

Loading content...

Implementors

Loading content...