structural-typing 0.1.3

Type-level field presence tracking for Rust structs, inspired by TypeScript
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

//! Type-level markers for field presence states.

use core::marker::PhantomData;

use crate::access::Access;

/// Marker indicating a field is present with a concrete value.
pub struct Present;
/// Marker indicating a field may or may not be present (Option).
pub struct Optional;
/// Marker indicating a field is absent (`PhantomData`).
pub struct Absent;

/// Trait for type-level presence markers with associated container types.
pub trait Presence {
    /// Presence when combined with Option.
    type OptionOrSelf: Presence;
    /// Result of merging this presence with another.
    type Or<Other: Presence>: Presence;
    /// Remainder when extracting Self: Present/Optional → Absent, Absent → Source.
    type RemainderFrom<Source: Presence>: Presence;
    /// Container type (T, Option\<T>, or `PhantomData`\<T>).
    type Output<T>: Access<T>;

    /// Merge two values, preferring the first if present.
    fn or<T, Other: Presence>(
        self_: <Self as Presence>::Output<T>,
        other: Other::Output<T>,
    ) -> <<Self as Presence>::Or<Other> as Presence>::Output<T>;

    /// Convert an Option into the appropriate presence state.
    fn option_or_self<T>(
        option: Option<T>,
        self_: <Self as Presence>::Output<T>,
    ) -> <<Self as Presence>::OptionOrSelf as Presence>::Output<T>;
}

/// Infers presence state from value type: `T` → Present, `Option<T>` → Optional, `PhantomData<T>` → Absent.
pub trait InferPresence<T> {
    /// The presence state corresponding to this value type.
    type Presence: Presence<Output<T> = Self>;
}

impl<T> InferPresence<T> for T {
    type Presence = Present;
}

impl<T> InferPresence<T> for Option<T> {
    type Presence = Optional;
}

impl<T> InferPresence<T> for PhantomData<T> {
    type Presence = Absent;
}

impl Presence for Present {
    type OptionOrSelf = Present;
    type Or<Other: Presence> = Present;
    type RemainderFrom<Source: Presence> = Absent;
    type Output<T> = T;

    #[inline]
    fn or<T, Other: Presence>(
        self_: <Self as Presence>::Output<T>,
        _other: Other::Output<T>,
    ) -> <<Self as Presence>::Or<Other> as Presence>::Output<T> {
        self_
    }

    #[inline]
    fn option_or_self<T>(
        option: Option<T>,
        self_: <Self as Presence>::Output<T>,
    ) -> <<Self as Presence>::OptionOrSelf as Presence>::Output<T> {
        option.unwrap_or(self_)
    }
}

impl Presence for Optional {
    type OptionOrSelf = Optional;
    type Or<Other: Presence> = Other::OptionOrSelf;
    type RemainderFrom<Source: Presence> = Absent;
    type Output<T> = Option<T>;

    #[inline]
    fn or<T, Other: Presence>(
        self_: <Self as Presence>::Output<T>,
        other: Other::Output<T>,
    ) -> <<Self as Presence>::Or<Other> as Presence>::Output<T> {
        Other::option_or_self(self_, other)
    }

    #[inline]
    fn option_or_self<T>(
        option: Option<T>,
        self_: <Self as Presence>::Output<T>,
    ) -> <<Self as Presence>::OptionOrSelf as Presence>::Output<T> {
        option.or(self_)
    }
}

impl Presence for Absent {
    type OptionOrSelf = Optional;
    type Or<Other: Presence> = Other;
    type RemainderFrom<Source: Presence> = Source;
    type Output<T> = PhantomData<T>;

    #[inline]
    fn or<T, Other: Presence>(
        _self: <Self as Presence>::Output<T>,
        other: Other::Output<T>,
    ) -> <<Self as Presence>::Or<Other> as Presence>::Output<T> {
        other
    }

    #[inline]
    fn option_or_self<T>(
        option: Option<T>,
        _self_: <Self as Presence>::Output<T>,
    ) -> <<Self as Presence>::OptionOrSelf as Presence>::Output<T> {
        option
    }
}