ghost-lite 0.1.2

custom PhantomData types
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

ghost_lite::ghost! {
    struct MMMM<T>
}

mod one_tp {
    use std::mem::size_of;

    ghost_lite::ghost! {
        struct MyPhantomData<T>
    }

    #[test]
    fn test() {
        let _ = MyPhantomData::<()>;
        let _: MyPhantomData<&str> = MyPhantomData;

        assert_eq!(size_of::<MyPhantomData<String>>(), 0);
    }
}

mod one_lt {
    use std::mem::size_of;

    ghost_lite::ghost! {
        struct MyPhantomData<'a>
    }

    #[test]
    fn test() {
        let _ = MyPhantomData::<'_>;
        let _ = MyPhantomData::<'static>;
        let _: MyPhantomData<'_> = MyPhantomData;
        let _: MyPhantomData<'static> = MyPhantomData;
        let _ = MyPhantomData;

        assert_eq!(size_of::<MyPhantomData>(), 0);
    }
}

mod only_tp {
    use std::mem::size_of;

    ghost_lite::ghost! {
        struct MyPhantomData<T, R>
    }

    #[test]
    fn test() {
        let _ = MyPhantomData::<(), i32>;
        let _: MyPhantomData<&str, ()> = MyPhantomData;

        assert_eq!(size_of::<MyPhantomData<String, &()>>(), 0);
    }
}

mod only_lt {
    use std::mem::size_of;

    ghost_lite::ghost! {
        struct MyPhantomData<'a, 'b>
    }

    #[test]
    fn test() {
        let _ = MyPhantomData::<'_, '_>;
        let _ = MyPhantomData::<'static, '_>;
        let _ = MyPhantomData::<'_, 'static>;
        let _ = MyPhantomData::<'static, 'static>;
        let _: MyPhantomData<'_, '_> = MyPhantomData;
        let _: MyPhantomData<'static, '_> = MyPhantomData;
        let _: MyPhantomData<'_, '_> = MyPhantomData;
        let _: MyPhantomData<'static, 'static> = MyPhantomData;
        let _ = MyPhantomData;

        assert_eq!(size_of::<MyPhantomData>(), 0);
    }
}

mod bounds {
    use std::mem::size_of;

    ghost_lite::ghost! {
        struct MyPhantomData<
            'lifetime,
            NoBound,
            OneBound: Copy,
            OneRelaxed: ?Sized,
            LifetimeAndOneBound: 'static + ToString,
            LifetimesAndOneBound: 'static + 'static + ToString,
            WhereClauseAndBounds: 'static + ToString,
            const N: usize,
        > where WhereClauseAndBounds: ?Sized
    }

    #[test]
    fn test() {
        assert_eq!(
            size_of::<
                MyPhantomData<
                    //
                    '_,
                    i32,
                    i8,
                    dyn ToString,
                    &'static str,
                    String,
                    dyn ToString,
                    1,
                >,
            >(),
            0
        );
    }
}