derive-ctor 1.0.3

Adds `#[derive(ctor)]` which allows for the auto-generation of struct, enum, and union constructors.
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

use derive_ctor::ctor;

#[derive(ctor, Debug, PartialEq)]
enum EnumUnitVariant {
    Variant1,
}

#[derive(ctor, Debug, PartialEq)]
enum EnumStructVariant {
    Variant { field: i32 },
}

#[derive(ctor, Debug, PartialEq)]
enum EnumNamelessVariant {
    Variant(i32),
}

#[test]
fn test_enum_variants() {
    let unit = EnumUnitVariant::variant1();
    assert_eq!(EnumUnitVariant::Variant1, unit);

    let struct_variant = EnumStructVariant::variant(13);
    assert_eq!(EnumStructVariant::Variant { field: 13 }, struct_variant);

    let nameless_variant = EnumNamelessVariant::variant(95);
    assert_eq!(EnumNamelessVariant::Variant(95), nameless_variant);
}

#[derive(ctor, Debug, PartialEq)]
enum MultipleVariants {
    Variant1,
    Variant2(i32),
    Variant3 { value: usize },
}

#[test]
fn test_enum_multiple_variants() {
    let v1 = MultipleVariants::variant1();
    assert_eq!(MultipleVariants::Variant1, v1);

    let v2 = MultipleVariants::variant2(123);
    assert_eq!(MultipleVariants::Variant2(123), v2);

    let v3 = MultipleVariants::variant3(888);
    assert_eq!(MultipleVariants::Variant3 { value: 888 }, v3);
}


#[derive(ctor, Debug, PartialEq)]
enum KeywordVariants {
    Break,
    Continue,
    Return,
    Fn
}

#[test]
fn test_enum_with_keyword_names() {
    assert_eq!(KeywordVariants::Break, KeywordVariants::r#break());
    assert_eq!(KeywordVariants::Continue, KeywordVariants::r#continue());
    assert_eq!(KeywordVariants::Return, KeywordVariants::r#return());
    assert_eq!(KeywordVariants::Fn, KeywordVariants::r#fn());
}