Trait Diff

pub trait Diff: Sized {
    type Repr;

    // Required methods
    fn diff(&self, other: &Self) -> Self::Repr;
    fn apply(&mut self, diff: &Self::Repr);
    fn identity() -> Self;

    // Provided methods
    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

Required Associated Types

type Repr

The type associated with the structs’ difference

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

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

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 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 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 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 i8

type Repr = i8

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

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

fn identity() -> i8

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 i32

type Repr = i32

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

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

fn identity() -> i32

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 isize

type Repr = isize

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

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

fn identity() -> isize

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 u16

type Repr = u16

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

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

fn identity() -> u16

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 u64

type Repr = u64

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

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

fn identity() -> u64

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 String

type Repr = Option<String>

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

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

fn identity() -> Self

impl Diff for PathBuf

type Repr = Option<PathBuf>

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

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

fn identity() -> Self

impl Diff for NonZeroU8

type Repr = u8

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

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

fn identity() -> NonZeroU8

impl Diff for NonZeroU16

type Repr = u16

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

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

fn identity() -> NonZeroU16

impl Diff for NonZeroU32

type Repr = u32

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

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

fn identity() -> NonZeroU32

impl Diff for NonZeroU64

type Repr = u64

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

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

fn identity() -> NonZeroU64

impl Diff for NonZeroU128

type Repr = u128

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

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

fn identity() -> NonZeroU128

impl Diff for NonZeroUsize

type Repr = usize

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

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

fn identity() -> NonZeroUsize

impl<'a> Diff for &'a str

type Repr = Option<&'a str>

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

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

fn identity() -> Self

impl<A> Diff for (A,)

where A: Diff,

type Repr = (<A as Diff>::Repr,)

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

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

fn identity() -> Self

impl<A, B> Diff for (A, B)

where A: Diff, B: Diff,

type Repr = (<A as Diff>::Repr, <B as Diff>::Repr)

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

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

fn identity() -> Self

impl<A, B, C> Diff for (A, B, C)

where A: Diff, B: Diff, C: Diff,

type Repr = (<A as Diff>::Repr, <B as Diff>::Repr, <C as Diff>::Repr)

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

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

fn identity() -> Self

impl<A, B, C, D> Diff for (A, B, C, D)

where A: Diff, B: Diff, C: Diff, D: Diff,

type Repr = (<A as Diff>::Repr, <B as Diff>::Repr, <C as Diff>::Repr, <D as Diff>::Repr)

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

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

fn identity() -> Self

impl<A, B, C, D, F> Diff for (A, B, C, D, F)

where A: Diff, B: Diff, C: Diff, D: Diff, F: Diff,

type Repr = (<A as Diff>::Repr, <B as Diff>::Repr, <C as Diff>::Repr, <D as Diff>::Repr, <F as Diff>::Repr)

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

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

fn identity() -> Self

impl<A, B, C, D, F, G> Diff for (A, B, C, D, F, G)

where A: Diff, B: Diff, C: Diff, D: Diff, F: Diff, G: Diff,

type Repr = (<A as Diff>::Repr, <B as Diff>::Repr, <C as Diff>::Repr, <D as Diff>::Repr, <F as Diff>::Repr, <G as Diff>::Repr)

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

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

fn identity() -> Self

impl<A, B, C, D, F, G, H> Diff for (A, B, C, D, F, G, H)

where A: Diff, B: Diff, C: Diff, D: Diff, F: Diff, G: Diff, H: Diff,

type Repr = (<A as Diff>::Repr, <B as Diff>::Repr, <C as Diff>::Repr, <D as Diff>::Repr, <F as Diff>::Repr, <G as Diff>::Repr, <H as Diff>::Repr)

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

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

fn identity() -> Self

impl<A, B, C, D, F, G, H, I> Diff for (A, B, C, D, F, G, H, I)

where A: Diff, B: Diff, C: Diff, D: Diff, F: Diff, G: Diff, H: Diff, I: Diff,

type Repr = (<A as Diff>::Repr, <B as Diff>::Repr, <C as Diff>::Repr, <D as Diff>::Repr, <F as Diff>::Repr, <G as Diff>::Repr, <H as Diff>::Repr, <I as Diff>::Repr)

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

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

fn identity() -> Self

impl<A, B, C, D, F, G, H, I, J> Diff for (A, B, C, D, F, G, H, I, J)

where A: Diff, B: Diff, C: Diff, D: Diff, F: Diff, G: Diff, H: Diff, I: Diff, J: Diff,

type Repr = (<A as Diff>::Repr, <B as Diff>::Repr, <C as Diff>::Repr, <D as Diff>::Repr, <F as Diff>::Repr, <G as Diff>::Repr, <H as Diff>::Repr, <I as Diff>::Repr, <J as Diff>::Repr)

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

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

fn identity() -> Self

impl<A, B, C, D, F, G, H, I, J, K> Diff for (A, B, C, D, F, G, H, I, J, K)

where A: Diff, B: Diff, C: Diff, D: Diff, F: Diff, G: Diff, H: Diff, I: Diff, J: Diff, K: Diff,

type Repr = (<A as Diff>::Repr, <B as Diff>::Repr, <C as Diff>::Repr, <D as Diff>::Repr, <F as Diff>::Repr, <G as Diff>::Repr, <H as Diff>::Repr, <I as Diff>::Repr, <J as Diff>::Repr, <K as Diff>::Repr)

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

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

fn identity() -> Self

impl<A, B, C, D, F, G, H, I, J, K, L> Diff for (A, B, C, D, F, G, H, I, J, K, L)

where A: Diff, B: Diff, C: Diff, D: Diff, F: Diff, G: Diff, H: Diff, I: Diff, J: Diff, K: Diff, L: Diff,

type Repr = (<A as Diff>::Repr, <B as Diff>::Repr, <C as Diff>::Repr, <D as Diff>::Repr, <F as Diff>::Repr, <G as Diff>::Repr, <H as Diff>::Repr, <I as Diff>::Repr, <J as Diff>::Repr, <K as Diff>::Repr, <L as Diff>::Repr)

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

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

fn identity() -> Self

impl<A, B, C, D, F, G, H, I, J, K, L, M> Diff for (A, B, C, D, F, G, H, I, J, K, L, M)

where A: Diff, B: Diff, C: Diff, D: Diff, F: Diff, G: Diff, H: Diff, I: Diff, J: Diff, K: Diff, L: Diff, M: Diff,

type Repr = (<A as Diff>::Repr, <B as Diff>::Repr, <C as Diff>::Repr, <D as Diff>::Repr, <F as Diff>::Repr, <G as Diff>::Repr, <H as Diff>::Repr, <I as Diff>::Repr, <J as Diff>::Repr, <K as Diff>::Repr, <L as Diff>::Repr, <M as Diff>::Repr)

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

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

fn identity() -> Self

impl<A, B, C, D, F, G, H, I, J, K, L, M, N> Diff for (A, B, C, D, F, G, H, I, J, K, L, M, N)

where A: Diff, B: Diff, C: Diff, D: Diff, F: Diff, G: Diff, H: Diff, I: Diff, J: Diff, K: Diff, L: Diff, M: Diff, N: Diff,

type Repr = (<A as Diff>::Repr, <B as Diff>::Repr, <C as Diff>::Repr, <D as Diff>::Repr, <F as Diff>::Repr, <G as Diff>::Repr, <H as Diff>::Repr, <I as Diff>::Repr, <J as Diff>::Repr, <K as Diff>::Repr, <L as Diff>::Repr, <M as Diff>::Repr, <N as Diff>::Repr)

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

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

fn identity() -> Self

impl<A, B, C, D, F, G, H, I, J, K, L, M, N, O> Diff for (A, B, C, D, F, G, H, I, J, K, L, M, N, O)

where A: Diff, B: Diff, C: Diff, D: Diff, F: Diff, G: Diff, H: Diff, I: Diff, J: Diff, K: Diff, L: Diff, M: Diff, N: Diff, O: Diff,

type Repr = (<A as Diff>::Repr, <B as Diff>::Repr, <C as Diff>::Repr, <D as Diff>::Repr, <F as Diff>::Repr, <G as Diff>::Repr, <H as Diff>::Repr, <I as Diff>::Repr, <J as Diff>::Repr, <K as Diff>::Repr, <L as Diff>::Repr, <M as Diff>::Repr, <N as Diff>::Repr, <O as Diff>::Repr)

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

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

fn identity() -> Self

impl<A, B, C, D, F, G, H, I, J, K, L, M, N, O, P> Diff for (A, B, C, D, F, G, H, I, J, K, L, M, N, O, P)

where A: Diff, B: Diff, C: Diff, D: Diff, F: Diff, G: Diff, H: Diff, I: Diff, J: Diff, K: Diff, L: Diff, M: Diff, N: Diff, O: Diff, P: Diff,

type Repr = (<A as Diff>::Repr, <B as Diff>::Repr, <C as Diff>::Repr, <D as Diff>::Repr, <F as Diff>::Repr, <G as Diff>::Repr, <H as Diff>::Repr, <I as Diff>::Repr, <J as Diff>::Repr, <K as Diff>::Repr, <L as Diff>::Repr, <M as Diff>::Repr, <N as Diff>::Repr, <O as Diff>::Repr, <P as Diff>::Repr)

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

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

fn identity() -> Self

impl<A, B, C, D, F, G, H, I, J, K, L, M, N, O, P, Q> Diff for (A, B, C, D, F, G, H, I, J, K, L, M, N, O, P, Q)

where A: Diff, B: Diff, C: Diff, D: Diff, F: Diff, G: Diff, H: Diff, I: Diff, J: Diff, K: Diff, L: Diff, M: Diff, N: Diff, O: Diff, P: Diff, Q: Diff,

type Repr = (<A as Diff>::Repr, <B as Diff>::Repr, <C as Diff>::Repr, <D as Diff>::Repr, <F as Diff>::Repr, <G as Diff>::Repr, <H as Diff>::Repr, <I as Diff>::Repr, <J as Diff>::Repr, <K as Diff>::Repr, <L as Diff>::Repr, <M as Diff>::Repr, <N as Diff>::Repr, <O as Diff>::Repr, <P as Diff>::Repr, <Q as Diff>::Repr)

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

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

fn identity() -> Self

impl<A, B, C, D, F, G, H, I, J, K, L, M, N, O, P, Q, R> Diff for (A, B, C, D, F, G, H, I, J, K, L, M, N, O, P, Q, R)

where A: Diff, B: Diff, C: Diff, D: Diff, F: Diff, G: Diff, H: Diff, I: Diff, J: Diff, K: Diff, L: Diff, M: Diff, N: Diff, O: Diff, P: Diff, Q: Diff, R: Diff,

type Repr = (<A as Diff>::Repr, <B as Diff>::Repr, <C as Diff>::Repr, <D as Diff>::Repr, <F as Diff>::Repr, <G as Diff>::Repr, <H as Diff>::Repr, <I as Diff>::Repr, <J as Diff>::Repr, <K as Diff>::Repr, <L as Diff>::Repr, <M as Diff>::Repr, <N as Diff>::Repr, <O as Diff>::Repr, <P as Diff>::Repr, <Q as Diff>::Repr, <R as Diff>::Repr)

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

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

fn identity() -> Self

impl<A, B, C, D, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> Diff for (A, B, C, D, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

where A: Diff, B: Diff, C: Diff, D: Diff, F: Diff, G: Diff, H: Diff, I: Diff, J: Diff, K: Diff, L: Diff, M: Diff, N: Diff, O: Diff, P: Diff, Q: Diff, R: Diff, S: Diff,

type Repr = (<A as Diff>::Repr, <B as Diff>::Repr, <C as Diff>::Repr, <D as Diff>::Repr, <F as Diff>::Repr, <G as Diff>::Repr, <H as Diff>::Repr, <I as Diff>::Repr, <J as Diff>::Repr, <K as Diff>::Repr, <L as Diff>::Repr, <M as Diff>::Repr, <N as Diff>::Repr, <O as Diff>::Repr, <P as Diff>::Repr, <Q as Diff>::Repr, <R as Diff>::Repr, <S as Diff>::Repr)

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

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

fn identity() -> Self

impl<K, V> Diff for BTreeMap<K, V>

where K: Clone + Ord, V: PartialEq + Diff,

type Repr = BTreeMapDiff<K, V>

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

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

fn identity() -> Self

impl<K, V> Diff for HashMap<K, V>

where K: Clone + Hash + Eq, V: PartialEq + Diff,

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 for Cow<'_, T>

where T: ToOwned + PartialEq + ?Sized, <T as ToOwned>::Owned: Clone + Default,

type Repr = Option<<T as ToOwned>::Owned>

Note: This was done to make sure a diff is able to outlive its sources, which is the most desirable outcome if the diff is to be moved around and consumed much later (or even serialized into foreign programs)

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

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

fn identity() -> Self

impl<T> Diff for Box<T>

where T: Diff,

type Repr = Box<<T as Diff>::Repr>

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

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

fn identity() -> Self

impl<T> Diff for BTreeSet<T>

where T: Clone + Ord,

type Repr = BTreeSetDiff<T>

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

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

fn identity() -> Self

impl<T> Diff for Rc<T>

where T: Diff + Clone,

type Repr = <T as Diff>::Repr

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

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

fn identity() -> Self

impl<T> Diff for Arc<T>

where T: Diff + Clone,

type Repr = <T as Diff>::Repr

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

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

fn identity() -> Self

impl<T> Diff for PhantomData<T>

type Repr = PhantomData<T>

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

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

fn identity() -> Self

impl<T> Diff for HashSet<T>

where T: Clone + Hash + Eq,

type Repr = HashSetDiff<T>

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<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

impl<T: Diff + PartialEq, const N: usize> Diff for [T; N]

type Repr = ArrayDiff<T>

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

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

fn identity() -> Self

Implementors