tynm 0.2.0

Returns type names in shorter form.
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

use alloc::string::String;

/// Holds both the short and full type names.
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct TypeNameInfo {
    /// The short type name, e.g. `"Option<String>"`.
    pub short_name: String,
    /// The full type name, e.g.
    /// `"core::option::Option<alloc::string::String>"`.
    pub full_name: String,
}

impl TypeNameInfo {
    /// Returns `TypeNameInfo` for the given `T`.
    pub fn new<T>() -> Self {
        let short_name = crate::type_name::<T>();
        let full_name = String::from(core::any::type_name::<T>());

        Self {
            short_name,
            full_name,
        }
    }
}

#[cfg(test)]
mod tests {
    use alloc::{format, string::String};

    use super::TypeNameInfo;

    #[test]
    fn clone() {
        let type_name_info = TypeNameInfo::new::<Option<String>>();

        let clone = Clone::clone(&type_name_info);

        assert_eq!(type_name_info, clone);
    }

    #[test]
    fn debug() {
        let type_name_info = TypeNameInfo::new::<Option<String>>();

        assert_eq!(
            "TypeNameInfo { \
                short_name: \"Option<String>\", \
                full_name: \"core::option::Option<alloc::string::String>\" \
            }",
            format!("{type_name_info:?}")
        );
    }

    #[cfg(feature = "serde")]
    #[test]
    fn serialize() -> Result<(), serde_yaml::Error> {
        let type_name_info = TypeNameInfo::new::<Option<String>>();

        let serialized = serde_yaml::to_string(&type_name_info)?;

        assert_eq!(
            "\
                short_name: Option<String>\n\
                full_name: core::option::Option<alloc::string::String>\n\
            ",
            serialized
        );

        Ok(())
    }

    #[cfg(feature = "serde")]
    #[test]
    fn deserialize() -> Result<(), serde_yaml::Error> {
        let deserialized = serde_yaml::from_str(
            "\
                short_name: Option<String>\n\
                full_name: core::option::Option<alloc::string::String>\n\
            ",
        )?;

        assert_eq!(TypeNameInfo::new::<Option<String>>(), deserialized);

        Ok(())
    }
}