type_hash 0.3.0

Generate a hash for a Rust type. The primary use-case for this crate is for detecting differences in message types between versions of a crate. The `TypeHash` trait is implemented for most built-in types and a derive macro is provided, for implementing it for your own 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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

use type_hash::TypeHash;

#[test]
fn same_built_in_type_has_same_hash() {
    assert_eq!(u64::type_hash(), u64::type_hash());
    assert_eq!(bool::type_hash(), bool::type_hash());
    assert_eq!(
        <(String, Vec::<&'static str>) as TypeHash>::type_hash(),
        <(String, Vec::<&'static str>) as TypeHash>::type_hash()
    );
}

#[test]
fn different_built_in_type_has_different_hash() {
    assert_ne!(u64::type_hash(), i64::type_hash());
    assert_ne!(bool::type_hash(), u8::type_hash());
    assert_ne!(
        <(String, Vec::<&'static mut str>) as TypeHash>::type_hash(),
        <(String, Vec::<&'static str>) as TypeHash>::type_hash()
    );
}

#[test]
fn same_custom_type_has_same_hash() {
    assert_eq!(v1::Foo::type_hash(), v1::Foo::type_hash());
    assert_eq!(v1::Bar::type_hash(), v1::Bar::type_hash());
    assert_eq!(v1::Wibble::type_hash(), v1::Wibble::type_hash());
}

#[test]
fn different_custom_type_with_same_name_and_structure_has_same_hash() {
    assert_eq!(v1::SameStruct::type_hash(), v2::SameStruct::type_hash());
    assert_eq!(v1::SameEnum::type_hash(), v2::SameEnum::type_hash());
}

#[test]
fn different_custom_type_with_overridden_field_type_has_same_hash() {
    assert_eq!(v1::Foo::type_hash(), v3::Foo::type_hash());
    assert_eq!(v1::SameStruct::type_hash(), v3::SameStruct::type_hash());
}

#[test]
fn custom_type_with_different_structure_has_different_hash() {
    assert_ne!(v1::Foo::type_hash(), v2::Foo::type_hash());
    assert_ne!(v1::Bar::type_hash(), v2::Bar::type_hash());
    assert_ne!(v1::Wibble::type_hash(), v2::Wibble::type_hash());
}

#[allow(unused)]
mod v1 {
    use type_hash::TypeHash;

    #[derive(TypeHash)]
    pub struct Foo {
        a: i64,
        b: String,
    }

    #[derive(TypeHash)]
    pub enum Bar {
        A = 1,
        B = 2,
    }

    #[derive(TypeHash)]
    pub enum Wibble {
        A(Bar),
        B(Foo, Foo),
        C { foo: Foo },
    }

    #[derive(TypeHash)]
    pub struct SameStruct {
        x: Vec<u32>,
        y: SameEnum,
    }

    #[derive(TypeHash)]
    pub enum SameEnum {
        X,
        Y(Box<[String]>, bool),
    }
}

#[allow(unused)]
mod v2 {
    use type_hash::TypeHash;

    #[derive(TypeHash)]
    pub struct Foo {
        a: u64, // <-- this field has a different type
        b: String,
    }

    #[derive(TypeHash)]
    pub enum Bar {
        A = 1,
        B = 3,
    }

    #[derive(TypeHash)]
    pub enum Wibble {
        A(Bar),
        B(Foo, Foo),
        C { foo: Foo },
    }

    #[derive(TypeHash)]
    pub struct SameStruct {
        x: Vec<u32>,
        y: SameEnum,
    }

    #[derive(TypeHash)]
    pub enum SameEnum {
        X,
        Y(Box<[String]>, bool),
    }
}

#[allow(unused)]
mod v3 {
    use type_hash::TypeHash;

    #[derive(TypeHash)]
    pub struct Foo {
        #[type_hash(as = "i64")]
        a: u64, // <-- this field has a different type, but treat it as the same
        b: String,
    }

    #[derive(TypeHash)]
    pub enum Bar {
        A = 1,
        B = 3,
    }

    #[derive(TypeHash)]
    pub enum Wibble {
        A(Bar),
        B(Foo, Foo),
        C { foo: Foo },
    }

    #[derive(TypeHash)]
    pub struct SameStruct {
        x: Vec<u32>,
        #[type_hash(as = "super::v1::SameEnum")]
        y: DifferentEnum,
    }

    #[derive(TypeHash)]
    pub enum DifferentEnum {
        X,
        Abc(bool),
    }
}