Diffable

Trait Diffable

pub trait Diffable {
    type Diff<'daft>
       where Self: 'daft;

    // Required method
    fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>;
}

Expand description

Represents a type which can be diffed.

For more information, see the crate-level documentation.

Required Associated Types§

type Diff<'daft> where Self: 'daft

The type of the diff.

This is a generic associated type, also known as a GAT. The 'daft lifetime is used in the diff method to ensure that the returned diff is valid for the lifetime of the input values.

Required Methods§

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

Compute the diff between two values.

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 Diffable for IpAddr

type Diff<'daft> = Leaf<&'daft IpAddr>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for SocketAddr

type Diff<'daft> = Leaf<&'daft SocketAddr>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for IpNet

Available on crate feature oxnet01 only.

type Diff<'daft> = Leaf<&'daft IpNet>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for bool

type Diff<'daft> = Leaf<&'daft bool>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for char

type Diff<'daft> = Leaf<&'daft char>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for i8

type Diff<'daft> = Leaf<&'daft i8>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for i16

type Diff<'daft> = Leaf<&'daft i16>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for i32

type Diff<'daft> = Leaf<&'daft i32>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for i64

type Diff<'daft> = Leaf<&'daft i64>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for isize

type Diff<'daft> = Leaf<&'daft isize>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for str

type Diff<'daft> = Leaf<&'daft str>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for u8

type Diff<'daft> = Leaf<&'daft u8>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for u16

type Diff<'daft> = Leaf<&'daft u16>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for u32

type Diff<'daft> = Leaf<&'daft u32>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for u64

type Diff<'daft> = Leaf<&'daft u64>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for ()

type Diff<'daft> = Leaf<&'daft ()>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for usize

type Diff<'daft> = Leaf<&'daft usize>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for String

Available on crate feature alloc only.

type Diff<'daft> = Leaf<&'daft str>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for Ipv4Addr

type Diff<'daft> = Leaf<&'daft Ipv4Addr>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for Ipv6Addr

type Diff<'daft> = Leaf<&'daft Ipv6Addr>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for SocketAddrV4

type Diff<'daft> = Leaf<&'daft SocketAddrV4>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for SocketAddrV6

type Diff<'daft> = Leaf<&'daft SocketAddrV6>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for OsStr

Available on crate feature std only.

type Diff<'daft> = Leaf<&'daft OsStr>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for OsString

Available on crate feature std only.

type Diff<'daft> = Leaf<&'daft OsStr>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for Path

Available on crate feature std only.

type Diff<'daft> = Leaf<&'daft Path>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for PathBuf

Available on crate feature std only.

type Diff<'daft> = Leaf<&'daft Path>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for Ipv4Net

Available on crate feature oxnet01 only.

type Diff<'daft> = Leaf<&'daft Ipv4Net>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for Ipv6Net

Available on crate feature oxnet01 only.

type Diff<'daft> = Leaf<&'daft Ipv6Net>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for Uuid

Available on crate feature uuid1 only.

type Diff<'daft> = Leaf<&'daft Uuid>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for NonZeroI8

type Diff<'daft> = Leaf<&'daft NonZero<i8>>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for NonZeroI16

type Diff<'daft> = Leaf<&'daft NonZero<i16>>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for NonZeroI32

type Diff<'daft> = Leaf<&'daft NonZero<i32>>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for NonZeroI64

type Diff<'daft> = Leaf<&'daft NonZero<i64>>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for NonZeroI128

type Diff<'daft> = Leaf<&'daft NonZero<i128>>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for NonZeroIsize

type Diff<'daft> = Leaf<&'daft NonZero<isize>>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for NonZeroU8

type Diff<'daft> = Leaf<&'daft NonZero<u8>>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for NonZeroU16

type Diff<'daft> = Leaf<&'daft NonZero<u16>>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for NonZeroU32

type Diff<'daft> = Leaf<&'daft NonZero<u32>>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for NonZeroU64

type Diff<'daft> = Leaf<&'daft NonZero<u64>>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for NonZeroU128

type Diff<'daft> = Leaf<&'daft NonZero<u128>>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl Diffable for NonZeroUsize

type Diff<'daft> = Leaf<&'daft NonZero<usize>>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<'a, T: Diffable + ?Sized> Diffable for &'a T

type Diff<'daft> = <T as Diffable>::Diff<'daft> where 'a: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<A: Diffable> Diffable for (A,)

type Diff<'daft> = (<A as Diffable>::Diff<'daft>,) where A: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<A: Diffable, B: Diffable> Diffable for (A, B)

type Diff<'daft> = (<A as Diffable>::Diff<'daft>, <B as Diffable>::Diff<'daft>) where A: 'daft, B: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<A: Diffable, B: Diffable, C: Diffable> Diffable for (A, B, C)

type Diff<'daft> = (<A as Diffable>::Diff<'daft>, <B as Diffable>::Diff<'daft>, <C as Diffable>::Diff<'daft>) where A: 'daft, B: 'daft, C: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<A: Diffable, B: Diffable, C: Diffable, D: Diffable> Diffable for (A, B, C, D)

type Diff<'daft> = (<A as Diffable>::Diff<'daft>, <B as Diffable>::Diff<'daft>, <C as Diffable>::Diff<'daft>, <D as Diffable>::Diff<'daft>) where A: 'daft, B: 'daft, C: 'daft, D: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<A: Diffable, B: Diffable, C: Diffable, D: Diffable, E: Diffable> Diffable for (A, B, C, D, E)

type Diff<'daft> = (<A as Diffable>::Diff<'daft>, <B as Diffable>::Diff<'daft>, <C as Diffable>::Diff<'daft>, <D as Diffable>::Diff<'daft>, <E as Diffable>::Diff<'daft>) where A: 'daft, B: 'daft, C: 'daft, D: 'daft, E: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<A: Diffable, B: Diffable, C: Diffable, D: Diffable, E: Diffable, F: Diffable> Diffable for (A, B, C, D, E, F)

type Diff<'daft> = (<A as Diffable>::Diff<'daft>, <B as Diffable>::Diff<'daft>, <C as Diffable>::Diff<'daft>, <D as Diffable>::Diff<'daft>, <E as Diffable>::Diff<'daft>, <F as Diffable>::Diff<'daft>) where A: 'daft, B: 'daft, C: 'daft, D: 'daft, E: 'daft, F: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<A: Diffable, B: Diffable, C: Diffable, D: Diffable, E: Diffable, F: Diffable, G: Diffable> Diffable for (A, B, C, D, E, F, G)

type Diff<'daft> = (<A as Diffable>::Diff<'daft>, <B as Diffable>::Diff<'daft>, <C as Diffable>::Diff<'daft>, <D as Diffable>::Diff<'daft>, <E as Diffable>::Diff<'daft>, <F as Diffable>::Diff<'daft>, <G as Diffable>::Diff<'daft>) where A: 'daft, B: 'daft, C: 'daft, D: 'daft, E: 'daft, F: 'daft, G: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<A: Diffable, B: Diffable, C: Diffable, D: Diffable, E: Diffable, F: Diffable, G: Diffable, H: Diffable> Diffable for (A, B, C, D, E, F, G, H)

type Diff<'daft> = (<A as Diffable>::Diff<'daft>, <B as Diffable>::Diff<'daft>, <C as Diffable>::Diff<'daft>, <D as Diffable>::Diff<'daft>, <E as Diffable>::Diff<'daft>, <F as Diffable>::Diff<'daft>, <G as Diffable>::Diff<'daft>, <H as Diffable>::Diff<'daft>) where A: 'daft, B: 'daft, C: 'daft, D: 'daft, E: 'daft, F: 'daft, G: 'daft, H: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<A: Diffable, B: Diffable, C: Diffable, D: Diffable, E: Diffable, F: Diffable, G: Diffable, H: Diffable, I: Diffable> Diffable for (A, B, C, D, E, F, G, H, I)

type Diff<'daft> = (<A as Diffable>::Diff<'daft>, <B as Diffable>::Diff<'daft>, <C as Diffable>::Diff<'daft>, <D as Diffable>::Diff<'daft>, <E as Diffable>::Diff<'daft>, <F as Diffable>::Diff<'daft>, <G as Diffable>::Diff<'daft>, <H as Diffable>::Diff<'daft>, <I as Diffable>::Diff<'daft>) where A: 'daft, B: 'daft, C: 'daft, D: 'daft, E: 'daft, F: 'daft, G: 'daft, H: 'daft, I: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

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

type Diff<'daft> = (<A as Diffable>::Diff<'daft>, <B as Diffable>::Diff<'daft>, <C as Diffable>::Diff<'daft>, <D as Diffable>::Diff<'daft>, <E as Diffable>::Diff<'daft>, <F as Diffable>::Diff<'daft>, <G as Diffable>::Diff<'daft>, <H as Diffable>::Diff<'daft>, <I as Diffable>::Diff<'daft>, <J as Diffable>::Diff<'daft>) where A: 'daft, B: 'daft, C: 'daft, D: 'daft, E: 'daft, F: 'daft, G: 'daft, H: 'daft, I: 'daft, J: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<K: Ord + Eq> Diffable for BTreeSet<K>

Available on crate feature alloc only.

type Diff<'daft> = BTreeSetDiff<'daft, K> where K: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<K: Ord + Eq, V> Diffable for BTreeMap<K, V>

Available on crate feature alloc only.

type Diff<'daft> = BTreeMapDiff<'daft, K, V> where K: 'daft, V: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<K: Hash + Eq> Diffable for HashSet<K>

Available on crate feature std only.

type Diff<'daft> = HashSetDiff<'daft, K> where K: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<K: Hash + Eq, V> Diffable for HashMap<K, V>

Available on crate feature std only.

type Diff<'daft> = HashMapDiff<'daft, K, V> where K: 'daft, V: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<T> Diffable for Option<T>

type Diff<'daft> = Leaf<Option<&'daft T>> where T: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<T> Diffable for TypedUuid<T>
where T: TypedUuidKind + Diffable,

Available on crate feature newtype-uuid1 only.

type Diff<'daft> = Leaf<&'daft TypedUuid<T>>

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<T, U> Diffable for Result<T, U>

type Diff<'daft> = Leaf<Result<&'daft T, &'daft U>> where T: 'daft, U: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<T: Diffable + ToOwned + ?Sized> Diffable for Cow<'_, T>

Available on crate feature alloc only.

type Diff<'daft> = <T as Diffable>::Diff<'daft> where Self: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<T: Diffable + ?Sized> Diffable for Box<T>

Available on crate feature alloc only.

type Diff<'daft> = <T as Diffable>::Diff<'daft> where T: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<T: Diffable + ?Sized> Diffable for Rc<T>

Available on crate feature alloc only.

type Diff<'daft> = <T as Diffable>::Diff<'daft> where T: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<T: Diffable + ?Sized> Diffable for Arc<T>

Available on crate feature alloc only.

type Diff<'daft> = <T as Diffable>::Diff<'daft> where T: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<T: Diffable> Diffable for [T]

Treat slices as leaf nodes.

type Diff<'daft> = Leaf<&'daft [T]> where T: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<T: Diffable> Diffable for Vec<T>

Available on crate feature alloc only.

Treat Vecs as Leafs

type Diff<'daft> = Leaf<&'daft [T]> where T: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<T: ?Sized> Diffable for RefCell<T>

type Diff<'daft> = Leaf<&'daft RefCell<T>> where T: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

impl<T: ?Sized> Diffable for PhantomData<T>

type Diff<'daft> = Leaf<&'daft PhantomData<T>> where Self: 'daft

fn diff<'daft>(&'daft self, other: &'daft Self) -> Self::Diff<'daft>

Implementors§