synonym 0.1.6

Customizable derive macro to create newtypes. It peeks into the underlying type to choose which traits should be implemented.
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

use synonym::Synonym;

#[derive(Synonym)]
struct TransparentString(String);

#[derive(Synonym)]
#[synonym(display = "LowerCase")]
struct LowerCaseString(String);

#[derive(Synonym)]
#[synonym(display = "UpperCase")]
struct UpperCaseString(String);

#[derive(Synonym)]
#[synonym(display = "opaque")]
struct OpaqueString(String);

#[derive(Synonym)]
#[synonym(display = "OpaqueLowerCase")]
struct OpaqueLowerCaseString(String);

#[derive(Synonym)]
#[synonym(display = "OpaqueUpperCase")]
struct OpaqueUpperCaseString(String);

#[derive(Synonym)]
#[synonym(display = "CustomFormat - {}")]
struct CustomString(String);

macro_rules! assert {
    ($expected:expr, $actual:expr) => (
        if $actual != $expected {
            panic!("Assertion failed! Expected: {}, got: {}", $expected, $actual)
        }
    )
}

fn main() {
    let transparent = TransparentString::from("transparent");
    let lower_case = LowerCaseString::from("Lower cAse");
    let upper_case = UpperCaseString::from("Upper Case");
    let opaque = OpaqueString::from("opaque");
    let opaque_lower_case = OpaqueLowerCaseString::from("Opaque Lower case");
    let opaque_upper_case = OpaqueUpperCaseString::from("opaque Upper Case");
    let custom = CustomString::from("custom");

    assert!("transparent", transparent.to_string());
    assert!("lower case", lower_case.to_string());
    assert!("UPPER CASE", upper_case.to_string());
    assert!("OpaqueString(opaque)", opaque.to_string());
    assert!("OpaqueLowerCaseString(opaque lower case)", opaque_lower_case.to_string());
    assert!("OpaqueUpperCaseString(OPAQUE UPPER CASE)", opaque_upper_case.to_string());
    assert!("CustomFormat - custom", custom.to_string());
}