patternize 0.1.1

provide macros and traits to create design pattern
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

extern crate patternize;

use std::{any::Any, sync::OnceLock};

use patternize::singleton::*;

#[test]
fn simple_struct() {
    #[generate_singleton]
    struct SimpleStruct {
        _data1: Box<String>,
        _data2: Box<String>,
    }

    assert_eq!(
        SIMPLE_STRUCT.type_id(),
        <OnceLock<SimpleStruct> as Any>::type_id(&OnceLock::new())
    );
}

#[test]
fn simple_enum() {
    #[generate_singleton]
    enum SimpleEnum {
        #[allow(dead_code)]
        Type1,
        #[allow(dead_code)]
        Type2(usize),
    }

    assert_eq!(
        SIMPLE_ENUM.type_id(),
        <OnceLock<SimpleEnum> as Any>::type_id(&OnceLock::new())
    );
}

#[test]
fn singleton_with_expr() {
    #[derive(Debug, PartialEq)]
    #[generate_singleton({ 
        let _do_nothing = 0 + 0;
        WithExprStruct { data: "string".to_string() }
    })]
    struct WithExprStruct {
        data: String,
    }

    assert_eq!(
        &*WITH_EXPR_STRUCT,
        &WithExprStruct {
            data: "string".to_string()
        }
    );

    // TODO:
    // NOTE: may fail because closure's type-id are not same before compiler substitute them for the same one
    // I don't know how to check that they are same type appropriately
    // assert_eq!(
    //     WITH_EXPR_STRUCT.type_id(),
    //     <LazyLock<WithExprStruct> as Any>::type_id(&LazyLock::new(|| {
    //
    //         let _do_nothing = 0 + 0;
    //         WithExprStruct {
    //             data: "string".to_string(),
    //         }
    //     }))
    // )
}