late-struct 0.1.0

Late-bound structure definitions.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use std::{any::Any, hash};

use crate::{LateInstance, LateStruct};

mod sealed {
    pub trait DynCloneSealed {}

    pub trait DynEqSealed {}

    pub trait DynPartialEqSealed {}

    pub trait DynHashSealed {}
}

// === DynClone === //

/// A bound for the [`LateStruct::EraseTo`] associated type which asserts that fields must have an
/// implementation of [`Clone`]. If `LateStruct::EraseTo` implements this trait, the
/// [`LateInstance`] instantiating that structure will implement `Clone`.
///
/// This trait is implemented for all types which implement `Clone`. Unlike `Clone`, however, it is
/// [`dyn` compatible].
///
/// ## Safety
///
/// This trait is sealed and no downstream crates can implement it.
///
/// [`dyn` compatible]: https://doc.rust-lang.org/1.87.0/reference/items/traits.html#r-items.traits.dyn-compatible
pub unsafe trait DynClone: sealed::DynCloneSealed {
    #[doc(hidden)]
    unsafe fn dyn_clone_into(&self, other: *mut u8);
}

impl<T: Clone> sealed::DynCloneSealed for T {}

unsafe impl<T: Clone> DynClone for T {
    unsafe fn dyn_clone_into(&self, other: *mut u8) {
        unsafe { other.cast::<T>().write(self.clone()) };
    }
}

impl<S: LateStruct> Clone for LateInstance<S>
where
    S::EraseTo: DynClone,
{
    fn clone(&self) -> Self {
        unsafe {
            Self::new_custom(|field, init| {
                self.get_erased(field).dyn_clone_into(init);
            })
        }
    }
}

// === DynEq === //

/// A bound for the [`LateStruct::EraseTo`] associated type which asserts that fields must have an
/// implementation of [`Eq`] against itself. If `LateStruct::EraseTo` implements this trait, the
/// [`LateInstance`] instantiating that structure will implement `Eq`.
///
/// This trait is implemented for all types which implement `Eq<Self>`. Unlike `Eq<Self>`, however,
/// it is [`dyn` compatible].
///
/// This trait is sealed and no downstream crates can implement it.
///
/// [`dyn` compatible]: https://doc.rust-lang.org/1.87.0/reference/items/traits.html#r-items.traits.dyn-compatible
pub trait DynEq: DynPartialEq + sealed::DynEqSealed {}

/// A bound for the [`LateStruct::EraseTo`] associated type which asserts that fields must have an
/// implementation of [`PartialEq`] against itself. If `LateStruct::EraseTo` implements this trait,
/// the [`LateInstance`] instantiating that structure will implement `PartialEq`.
///
/// This trait is implemented for all types which implement `PartialEq<Self>`. Unlike
/// `PartialEq<Self>`, however, it is [`dyn` compatible].
///
/// This trait is sealed and no downstream crates can implement it.
///
/// [`dyn` compatible]: https://doc.rust-lang.org/1.87.0/reference/items/traits.html#r-items.traits.dyn-compatible
pub trait DynPartialEq: Any + sealed::DynPartialEqSealed {
    #[doc(hidden)]
    fn dyn_eq(&self, other: &dyn Any) -> bool;

    #[doc(hidden)]
    fn as_any(&self) -> &dyn Any;
}

impl<T: 'static + Eq> sealed::DynEqSealed for T {}

impl<T: 'static + Eq> DynEq for T {}

impl<T: 'static + PartialEq> sealed::DynPartialEqSealed for T {}

impl<T: 'static + PartialEq> DynPartialEq for T {
    fn dyn_eq(&self, other: &dyn Any) -> bool {
        other.downcast_ref::<T>().is_some_and(|rhs| self == rhs)
    }

    fn as_any(&self) -> &dyn Any {
        self
    }
}

impl<S: LateStruct> Eq for LateInstance<S> where S::EraseTo: DynEq {}

impl<S: LateStruct> PartialEq for LateInstance<S>
where
    S::EraseTo: DynEq,
{
    fn eq(&self, other: &Self) -> bool {
        self.fields().iter().all(|&field| {
            self.get_erased(field)
                .dyn_eq(other.get_erased(field).as_any())
        })
    }
}

// === DynHash === //

/// A bound for the [`LateStruct::EraseTo`] associated type which asserts that fields must have an
/// implementation of [`Hash`]. If `LateStruct::EraseTo` implements this trait, the [`LateInstance`]
/// instantiating that structure will implement `Hash`.
///
/// This trait is implemented for all types which implement `Hash`. Unlike `Hash`, however,
/// it is [`dyn` compatible].
///
/// This trait is sealed and no downstream crates can implement it.
///
/// [`dyn` compatible]: https://doc.rust-lang.org/1.87.0/reference/items/traits.html#r-items.traits.dyn-compatible
pub trait DynHash: sealed::DynHashSealed {
    #[doc(hidden)]
    fn dyn_hash(&self, hasher: &mut dyn hash::Hasher);
}

impl<T: hash::Hash> sealed::DynHashSealed for T {}

impl<T: hash::Hash> DynHash for T {
    fn dyn_hash(&self, mut hasher: &mut dyn hash::Hasher) {
        self.hash(&mut hasher);
    }
}

impl<S: LateStruct> hash::Hash for LateInstance<S>
where
    S::EraseTo: DynHash,
{
    fn hash<H: hash::Hasher>(&self, state: &mut H) {
        for field in self.fields() {
            self.get_erased(field).dyn_hash(state);
        }
    }
}