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
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184

use disjoint_impls::disjoint_impls;

pub trait Dispatch {
    type Group;
}

pub trait Tr {
    type A;
}

pub enum GroupA {}
impl Dispatch for String {
    type Group = GroupA;
}
impl Tr for String {
    type A = [(Self,); 1];
}
impl Dispatch for (String,) {
    type Group = [GroupA; 1];
}

impl<T> Dispatch for Vec<T> {
    type Group = GroupA;
}
impl<T> Tr for Vec<T> {
    type A = [(Self,); 1];
}
impl<T> Dispatch for (Vec<T>,) {
    type Group = [u32; 2];
}

pub enum GroupB {}
impl Tr for i32 {
    type A = [i16; 2];
}
impl Dispatch for i32 {
    type Group = GroupB;
}
impl Tr for u32 {
    type A = [i16; 2];
}
impl Dispatch for u32 {
    type Group = GroupB;
}
impl Dispatch for i16 {
    type Group = GroupB;
}

disjoint_impls! {
    pub trait Kita {
        const NAME: &'static str;
    }

    impl<T: Dispatch<Group = GroupA>, A: Dispatch<Group = [Z; 1]>, Z> Kita for T
    where
        Self: Tr<A = [A; 1]>,
    {
        const NAME: &'static str = "1st Blanket AA";
    }
    impl<T: Dispatch<Group = GroupA> + Tr<A = [A; 1]>, A: Dispatch<Group = [Z; 2]>, Z> Kita for T {
        const NAME: &'static str = "1st Blanket AB";
    }
    impl<T: Dispatch<Group = GroupB> + Tr<A = [A; 2]>, A: Dispatch> Kita for T {
        const NAME: &'static str = "1st Blanket B*";
    }

    impl<T: Dispatch<Group = GroupA> + Tr<A = [A; 1]>, A: Dispatch<Group = [u16; 1]>> Kita for [T; 1] {
        const NAME: &'static str = "2nd Blanket AA";
    }
    impl<T: Dispatch<Group = GroupA> + Tr<A = [A; 1]>, A: Dispatch<Group = [u16; 2]>> Kita for [T; 1] {
        const NAME: &'static str = "2nd Blanket AB";
    }
    impl<T: Dispatch<Group = GroupB> + Tr<A = [A; 2]>, A: Dispatch> Kita for [T; 1] {
        const NAME: &'static str = "2nd Blanket B*";
    }
}

/*
pub trait Kita {
    const NAME: &'static str;
}
const _: () = {
    pub trait Kita0<
        _TŠČ0: ?core::marker::Sized,
        _TŠČ1: ?core::marker::Sized,
        _TŠČ2: ?core::marker::Sized,
    >: Kita {
        const NAME_šč: &'static str;
    }
    impl<
        T: Dispatch<Group = GroupA>,
        A: Dispatch<Group = [Z; 1]>,
        Z,
    > Kita0<GroupA, [A; 1], [Z; 1]> for T
    where
        T: Tr<A = [A; 1]>,
    {
        const NAME_šč: &'static str = "1st Blanket AA";
    }
    impl<
        T: Dispatch<Group = GroupA> + Tr<A = [A; 1]>,
        A: Dispatch<Group = [Z; 2]>,
        Z,
    > Kita0<GroupA, [A; 1], [Z; 2]> for T {
        const NAME_šč: &'static str = "1st Blanket AB";
    }
    impl<
        T: Dispatch<Group = GroupB> + Tr<A = [A; 2]>,
        A: Dispatch,
    > Kita0<GroupB, [A; 2], <A as Dispatch>::Group> for T {
        const NAME_šč: &'static str = "1st Blanket B*";
    }
    pub trait Kita1<
        _TŠČ0: ?core::marker::Sized,
        _TŠČ1: ?core::marker::Sized,
        _TŠČ2: ?core::marker::Sized,
    >: Kita {
        const NAME_šč: &'static str;
    }
    impl<
        T: Dispatch<Group = GroupA> + Tr<A = [A; 1]>,
        A: Dispatch<Group = [u16; 1]>,
    > Kita1<GroupA, [A; 1], [u16; 1]> for [T; 1] {
        const NAME_šč: &'static str = "2nd Blanket AA";
    }
    impl<
        T: Dispatch<Group = GroupA> + Tr<A = [A; 1]>,
        A: Dispatch<Group = [u16; 2]>,
    > Kita1<GroupA, [A; 1], [u16; 2]> for [T; 1] {
        const NAME_šč: &'static str = "2nd Blanket AB";
    }
    impl<
        T: Dispatch<Group = GroupB> + Tr<A = [A; 2]>,
        A: Dispatch,
    > Kita1<GroupB, [A; 2], <A as Dispatch>::Group> for [T; 1] {
        const NAME_šč: &'static str = "2nd Blanket B*";
    }
    impl<_TŠČ0, _TŠČ2, const _CŠČ0: usize> Kita for _TŠČ0
    where
        _TŠČ0: Dispatch,
        _TŠČ0: Tr<A = [_TŠČ2; _CŠČ0]>,
        _TŠČ2: Dispatch,
        Self: for<'_dšč> Kita0<
            <_TŠČ0 as Dispatch>::Group,
            [_TŠČ2; _CŠČ0],
            <_TŠČ2 as Dispatch>::Group,
        >,
    {
        const NAME: &'static str = <Self as Kita0<
            <_TŠČ0 as Dispatch>::Group,
            [_TŠČ2; _CŠČ0],
            <_TŠČ2 as Dispatch>::Group,
        >>::NAME_šč;
    }
    impl<_TŠČ0, _TŠČ2, const _CŠČ0: usize> Kita for [_TŠČ0; 1]
    where
        _TŠČ0: Dispatch,
        _TŠČ0: Tr<A = [_TŠČ2; _CŠČ0]>,
        _TŠČ2: Dispatch,
        Self: for<'_dšč> Kita1<
            <_TŠČ0 as Dispatch>::Group,
            [_TŠČ2; _CŠČ0],
            <_TŠČ2 as Dispatch>::Group,
        >,
    {
        const NAME: &'static str = <Self as Kita1<
            <_TŠČ0 as Dispatch>::Group,
            [_TŠČ2; _CŠČ0],
            <_TŠČ2 as Dispatch>::Group,
        >>::NAME_šč;
    }
};
*/

#[test]
fn unconstrained_params() {
    assert_eq!("1st Blanket AA", String::NAME);
    assert_eq!("1st Blanket AB", Vec::<u32>::NAME);
    assert_eq!("1st Blanket B*", u32::NAME);
    assert_eq!("1st Blanket B*", i32::NAME);

    assert_eq!("2nd Blanket B*", <[u32; 1]>::NAME);
    assert_eq!("2nd Blanket B*", <[i32; 1]>::NAME);
}