typekin 0.6.0

new-type pattern with concept of Friends borrowed from c++, no-std and fully const
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

#![allow(dead_code)]
#![feature(const_clone)]
#![feature(const_cmp)]
#![feature(const_convert)]
#![feature(const_destruct)]
#![feature(const_iter)]
#![feature(const_ops)]
#![feature(const_trait_impl)]
#![feature(derive_const)]

mod subject {
    #[derive_const(Clone, Eq, PartialEq, Ord, PartialOrd)]
    #[derive(Copy, Debug, Hash)]
    #[repr(u128)]
    #[typekin::bitflag(
        integral = [
            konst = true,
            friends = [u128, MyFlag(level=[Bit])] // Only for test utils.
        ],
    )]
    pub enum MyFlag {
        Z = 0,
        A = 10,
        B,
        C = 40,
    }

    impl MyFlag {
        #[inline(always)]
        #[must_use]
        pub const fn empty() -> Self {
            return Self::Z;
        }
    }
}

type Subject = subject::MyFlag;
type Value = subject::MyFlagValue;

fn main() {
    let lhs = Subject::A;
    let rhs = Subject::B.into_value();

    println!("{:?}", (lhs & rhs) == (lhs & rhs));
    println!("{:?}", rhs & lhs);
    println!("{:?}", lhs & rhs);

    for x in Subject::items() {
        println!("{}", x.name());
    }
}