disjoint_impls 1.4.0

Support for mutually disjoint impls
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
152
153
154
155
156
157
158
159
160
161
162
163
164
165

use disjoint_impls::disjoint_impls;

pub trait Dispatch {
    type Group;
}

pub enum GroupA {}
impl Dispatch for Counted<String> {
    type Group = GroupA;
}
impl<T> Dispatch for Counted<Vec<T>> {
    type Group = GroupA;
}

pub enum GroupB {}
impl Dispatch for i32 {
    type Group = GroupB;
}
impl Dispatch for u32 {
    type Group = GroupB;
}

trait Counter {
    fn decrement(&mut self) -> u32;
}

struct Counted<T>(u32, T);
impl<T> Counter for Counted<T> {
    fn decrement(&mut self) -> u32 {
        self.0 = self.0.saturating_sub(1);
        self.0
    }
}

disjoint_impls! {
    pub trait Kita {
        type Item;

        fn kita(&mut self) -> Self::Item;
    }

    impl<T: Dispatch<Group = GroupA> + Counter> Kita for T {
        type Item = u32;

        fn kita(&mut self) -> u32 {
            let _value = self.decrement();
            let _value = Self::decrement(self);
            let value = T::decrement(self);

            if value == 0 {
                return 0;
            }

            // FIXME: Support this!
            //let _value = self.kita();
            //let _value = Self::kita(self);
            //let value = T::kita(self);
            let _value = <Self as Kita>::kita(self);
            let value = <T as Kita>::kita(self);

            value + 1
        }
    }
    impl<U: Dispatch<Group = GroupB> + Default> Kita for U {
        type Item = U;

        fn kita(&mut self) -> Self::Item {
            <U as Default>::default()
        }
    }

    impl<T: Dispatch<Group = GroupA>> Kita for (T,) {
        type Item = u32;

        fn kita(&mut self) -> u32 {
            let a: Self::Item = <u32 as Kita>::kita(&mut 33);
            a
        }
    }
    impl<U: Dispatch<Group = GroupB> + Default> Kita for (U,) {
        type Item = U;

        fn kita(&mut self) -> Self::Item {
            <U as Default>::default()
        }
    }
}

/*
pub trait Kita {
    type Item;
    fn kita(&mut self) -> Self::Item;
}
const _: () = {
    pub trait Kita0<_TŠČ0: ?core::marker::Sized>: Kita {
        type Item_šč;
        fn kita_šč(&mut self) -> Self::Item;
    }
    impl<T: Dispatch<Group = GroupA> + Counter> Kita0<GroupA> for T {
        type Item_šč = u32;
        fn kita_šč(&mut self) -> u32 {
            let _value = self.decrement();
            let _value = Self::decrement(self);
            let value = T::decrement(self);
            if value == 0 {
                return 0;
            }
            let _value = <Self as Kita>::kita(self);
            let value = <T as Kita>::kita(self);
            value + 1
        }
    }
    impl<U: Dispatch<Group = GroupB> + Default> Kita0<GroupB> for U {
        type Item_šč = U;
        fn kita_šč(&mut self) -> Self::Item {
            <U as Default>::default()
        }
    }
    pub trait Kita1<_TŠČ0: ?core::marker::Sized>: Kita {
        type Item_šč;
        fn kita_šč(&mut self) -> Self::Item;
    }
    impl<T: Dispatch<Group = GroupA>> Kita1<GroupA> for (T,) {
        type Item_šč = u32;
        fn kita_šč(&mut self) -> u32 {
            let a: Self::Item = <u32 as Kita>::kita(&mut 33);
            a
        }
    }
    impl<U: Dispatch<Group = GroupB> + Default> Kita1<GroupB> for (U,) {
        type Item_šč = U;
        fn kita_šč(&mut self) -> Self::Item {
            <U as Default>::default()
        }
    }
    impl<_TŠČ0> Kita for _TŠČ0
    where
        _TŠČ0: Dispatch,
        Self: for<'_dšč> Kita0<<_TŠČ0 as Dispatch>::Group>,
    {
        type Item = <Self as Kita0<<_TŠČ0 as Dispatch>::Group>>::Item_šč;
        fn kita(&mut self) -> Self::Item {
            <Self as Kita0<<_TŠČ0 as Dispatch>::Group>>::kita_šč(self)
        }
    }
    impl<_TŠČ0> Kita for (_TŠČ0,)
    where
        _TŠČ0: Dispatch,
        Self: for<'_dšč> Kita1<<_TŠČ0 as Dispatch>::Group>,
    {
        type Item = <Self as Kita1<<_TŠČ0 as Dispatch>::Group>>::Item_šč;
        fn kita(&mut self) -> Self::Item {
            <Self as Kita1<<_TŠČ0 as Dispatch>::Group>>::kita_šč(self)
        }
    }
};
*/

#[test]
fn recursive_call() {
    assert_eq!(0, Counted::<String>::kita(&mut Counted(2, "a".to_string())));
    assert_eq!(1, Counted::<Vec::<u32>>::kita(&mut Counted(12, vec![])));
    assert_eq!(0, u32::kita(&mut 12));
    assert_eq!(0, i32::kita(&mut 42));
}