const_struct 0.6.5

macro that allows const structures to be passed as const generics
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

use super::PrimitiveTraits;

pub trait TupleTy<T> {
    const __DATA: T;
    const VALUE: T = Self::__DATA;
}

impl TupleTy<()> for () {
    const __DATA: () = ();
}

macro_rules! TupleTyByNum {
    ($($generics:ident),*) => {
        impl<T: PrimitiveTraits<DATATYPE = ($($generics),*, )>, $($generics),*> TupleTy<($($generics),*, )> for T {
            const __DATA: ($($generics),*, ) = <T as PrimitiveTraits>::__DATA;
        }

        impl<$($generics: PrimitiveTraits),*> PrimitiveTraits for ($($generics),*, ) {
            type DATATYPE = ($($generics::DATATYPE),*, );
            const __DATA: Self::DATATYPE = ($($generics::__DATA),*, );
        }
    };
}

TupleTyByNum!(A);
TupleTyByNum!(A, B);
TupleTyByNum!(A, B, C);
TupleTyByNum!(A, B, C, D);
TupleTyByNum!(A, B, C, D, E);
TupleTyByNum!(A, B, C, D, E, F);
TupleTyByNum!(A, B, C, D, E, F, G);
TupleTyByNum!(A, B, C, D, E, F, G, H);
TupleTyByNum!(A, B, C, D, E, F, G, H, I);
TupleTyByNum!(A, B, C, D, E, F, G, H, I, J);

#[cfg(test)]
mod tests {
    use crate::primitive::{F32, F64, U32};
    use core::mem;

    use super::TupleTy;

    pub const fn tester_inner0<T: TupleTy<()>>() {
        T::VALUE
    }

    pub const fn tester_inner1<T: TupleTy<(f32,)>>() -> (f32,) {
        T::VALUE
    }

    pub const fn tester_inner2<T: TupleTy<(f32, f64)>>() -> (f32, f64) {
        T::VALUE
    }

    pub const fn tester_inner3<T: TupleTy<(f32, (f64, u32))>>() -> (f32, (f64, u32)) {
        T::VALUE
    }

    pub const fn tester_inner4<T: TupleTy<(f32, f32, f32, f32)>>() -> (f32, f32, f32, f32) {
        T::VALUE
    }

    #[test]
    fn call_tester() {
        let s: (F32!(0.4), F64!(0.3)) = unsafe { mem::zeroed() };
        assert_eq!(core::mem::size_of_val(&s), 0);
        assert_eq!(tester_inner0::<()>(), ());
        assert_eq!(tester_inner1::<(F32!(0.4),)>(), (0.4,));
        assert_eq!(tester_inner2::<(F32!(0.4), F64!(0.3))>(), (0.4, 0.3));
        assert_eq!(
            tester_inner3::<(F32!(0.4), (F64!(0.3), U32!(5)))>(),
            (0.4, (0.3, 5))
        );
        assert_eq!(
            tester_inner4::<(F32!(0.4), F32!(0.3), F32!(0.2), F32!(0.1))>(),
            (0.4, 0.3, 0.2, 0.1)
        );
    }
}