treaty -


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
152
153
154
155
156
157
158
159
160
161
162

//! Wrapper types that impl [`TypeNameable`] when their generic type is `'static`.

use super::*;

/// Impl of [`TypeNameable`] for `'static` types that are owned (`T`).
#[derive(PartialEq, Clone, Copy, Debug)]
#[repr(transparent)]
pub struct OwnedStatic<T: ?Sized>(pub T);

// bijective_higher_ranked_type! {
//     pub type DynOwnedStatic['lt][T][]: MaybeSized['lt][]
//     for<'a>
//     (OwnedStatic<T>)
//     where {
//         T: ?Sized + 'lt
//     }
// }

pub struct DynOwnedStatic<T: ?Sized>(PhantomData<fn() -> *const T>);

impl<'a, 'lt, T: ?Sized + 'lt> MaybeSized::LowerForLt<'a, 'lt, &'a (&'lt (),)>
    for DynOwnedStatic<T>
{
    type T = OwnedStatic<T>;
}

impl<'a, 'lt, T: ?Sized + 'lt> MaybeSized::RaiseForLt<'a, 'lt, &'a (&'lt (),)> for OwnedStatic<T> {
    type HigherRanked = DynOwnedStatic<T>;
}

bijective_higher_ranked_type! {
    pub type [][T][]: TypeName[][]
    for<'lt>
    (DynOwnedStatic<T>)
    where {
        T: ?Sized + 'static
    }
}

/// Impl of [`TypeNameable`] for `'static` types that are borrowed (`&'lt T`).
#[repr(transparent)]
pub struct BorrowedStatic<'lt, T: ?Sized>(pub &'lt T);

bijective_higher_ranked_type! {
    pub type DynBorrowedStatic['lt][T]: MaybeSized['lt][]
    for<'a>
    (BorrowedStatic<'lt, T>)
    where {
        T: ?Sized + 'lt,
    }
}

bijective_higher_ranked_type! {
    pub type [][T][]: TypeName[][]
    for<'lt>
    (DynBorrowedStatic<'lt, T>)
    where {
        T: ?Sized + 'static
    }
}

/// Impl of [`TypeNameable`] for `'static` types that are temporarily borrowed (`&'a T`).
#[repr(transparent)]
pub struct TempBorrowedStatic<'a, T: ?Sized>(pub &'a T);

bijective_higher_ranked_type! {
    pub type DynTempBorrowedStatic['lt][T]: MaybeSized['lt][]
    for<'a>
    (TempBorrowedStatic<'a, T>)
    where {
        T: ?Sized + 'lt,
    }
}

bijective_higher_ranked_type! {
    pub type [][T][]: TypeName[][]
    for<'lt>
    (DynTempBorrowedStatic<'lt, T>)
    where {
        T: ?Sized + 'static
    }
}

/// Impl of [`TypeNameable`] for `'static` types that are borrowed mutably (`&'lt mut T`).
#[repr(transparent)]
pub struct BorrowedMutStatic<'lt, T: ?Sized>(pub &'lt mut T);

bijective_higher_ranked_type! {
    pub type DynBorrowedMutStatic['lt][T]: MaybeSized['lt][]
    for<'a>
    (BorrowedMutStatic<'lt, T>)
    where {
        T: ?Sized + 'lt,
    }
}

bijective_higher_ranked_type! {
    pub type [][T][]: TypeName[][]
    for<'lt>
    (DynBorrowedMutStatic<'lt, T>)
    where {
        T: ?Sized + 'static
    }
}

/// Impl of [`TypeNameable`] for `'static` types that are temporarily borrowed mutably (`&'a mut T`).
#[repr(transparent)]
pub struct TempBorrowedMutStatic<'a, T: ?Sized>(pub &'a mut T);

bijective_higher_ranked_type! {
    pub type DynTempBorrowedMutStatic['lt][T]: MaybeSized['lt][]
    for<'a>
    (TempBorrowedMutStatic<'a, T>)
    where {
        T: ?Sized + 'lt,
    }
}

bijective_higher_ranked_type! {
    pub type [][T][]: TypeName[][]
    for<'lt>
    (DynTempBorrowedMutStatic<'lt, T>)
    where {
        T: ?Sized + 'static
    }
}

/// Impl of [`TypeNameable`] for `'static` types that are in a [`Box`] (`Box<T>`).
#[cfg(feature = "alloc")]
pub struct BoxedStatic<T: ?Sized>(pub Box<T>);

#[cfg(feature = "alloc")]
bijective_higher_ranked_type! {
    pub type DynBoxedStatic['lt][T]: MaybeSized['lt][]
    for<'a>
    (BoxedStatic<T>)
    where {
        T: ?Sized + 'lt,
    }
}

#[cfg(feature = "alloc")]
bijective_higher_ranked_type! {
    pub type [][T][]: TypeName[][]
    for<'lt>
    (DynBoxedStatic<'lt, T>)
    where {
        T: ?Sized + 'static
    }
}

#[derive(Debug)]
pub enum BorrowedStaticValue<'ctx, T: ?Sized + 'static> {
    Ctx(&'ctx T),
    Static(&'static T),
}

#[derive(Debug)]
pub enum BorrowedMutStaticValue<'ctx, T: ?Sized + 'static> {
    Ctx(&'ctx mut T),
    Static(&'static mut T),
}