humfmt 0.5.2

Ergonomic human-readable formatting toolkit for Rust
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

/// Extension trait providing ergonomic `.human_*()` methods.
///
/// This trait is implemented for all types (`impl<T> Humanize for T {}`),
/// but each method is only available when the receiver implements the
/// corresponding `*Like` trait (`BytesLike`, `NumberLike`, etc.).
///
/// This keeps the API baby-simple:
///
/// ```rust
/// use humfmt::Humanize;
///
/// assert_eq!(1_500_000.human_number().to_string(), "1.5M");
/// assert_eq!(1536_u64.human_bytes().to_string(), "1.5KB");
/// assert_eq!(0.423_f64.human_percent().to_string(), "42.3%");
/// ```
pub trait Humanize: Sized {
    /// Formats this value as a human-readable byte size using default options.
    fn human_bytes(self) -> crate::bytes::BytesDisplay
    where
        Self: crate::bytes::BytesLike,
    {
        crate::bytes::bytes(self)
    }

    /// Formats this value as a human-readable byte size using custom options.
    fn human_bytes_with(self, options: crate::bytes::BytesOptions) -> crate::bytes::BytesDisplay
    where
        Self: crate::bytes::BytesLike,
    {
        crate::bytes::bytes_with(self, options)
    }

    /// Formats this duration as relative time using default options.
    ///
    /// Output is localized via the active locale in [`crate::DurationOptions`].
    fn human_ago(self) -> crate::ago::AgoDisplay
    where
        Self: crate::duration::DurationLike,
    {
        crate::ago::ago(self)
    }

    /// Formats this duration as relative time using custom duration options.
    fn human_ago_with<L: crate::locale::Locale>(
        self,
        options: crate::duration::DurationOptions<L>,
    ) -> crate::ago::AgoDisplay<L>
    where
        Self: crate::duration::DurationLike,
    {
        crate::ago::ago_with(self, options)
    }

    /// Formats this duration using default options.
    fn human_duration(self) -> crate::duration::DurationDisplay
    where
        Self: crate::duration::DurationLike,
    {
        crate::duration::duration(self)
    }

    /// Formats this duration using custom duration options.
    fn human_duration_with<L: crate::locale::Locale>(
        self,
        options: crate::duration::DurationOptions<L>,
    ) -> crate::duration::DurationDisplay<L>
    where
        Self: crate::duration::DurationLike,
    {
        crate::duration::duration_with(self, options)
    }

    /// Formats this numeric value as a compact human-readable number using default options.
    fn human_number(self) -> crate::number::NumberDisplay<crate::locale::English>
    where
        Self: crate::number::NumberLike,
    {
        crate::number::number(self)
    }

    /// Formats this numeric value as a compact human-readable number using custom options.
    fn human_number_with<L: crate::locale::Locale>(
        self,
        options: crate::number::NumberOptions<L>,
    ) -> crate::number::NumberDisplay<L>
    where
        Self: crate::number::NumberLike,
    {
        crate::number::number_with(self, options)
    }

    /// Formats this value as an ordinal number using the default locale (English).
    fn human_ordinal(self) -> crate::ordinal::OrdinalDisplay<crate::locale::English>
    where
        Self: crate::ordinal::OrdinalLike,
    {
        crate::ordinal::ordinal(self)
    }

    /// Formats this value as an ordinal number using a custom locale.
    fn human_ordinal_with<L: crate::locale::Locale>(
        self,
        locale: L,
    ) -> crate::ordinal::OrdinalDisplay<L>
    where
        Self: crate::ordinal::OrdinalLike,
    {
        crate::ordinal::ordinal_with(self, locale)
    }

    /// Formats this value as a human-readable percentage using default options.
    ///
    /// The input is a ratio: `1.0` means `100%`, `0.5` means `50%`.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use humfmt::Humanize;
    ///
    /// assert_eq!(0.423_f64.human_percent().to_string(), "42.3%");
    /// assert_eq!(1.0_f64.human_percent().to_string(), "100%");
    /// ```
    fn human_percent(self) -> crate::percent::PercentDisplay<crate::locale::English>
    where
        Self: crate::percent::PercentLike,
    {
        crate::percent::percent(self)
    }

    /// Formats this value as a human-readable percentage using custom options.
    fn human_percent_with<L: crate::locale::Locale>(
        self,
        options: crate::percent::PercentOptions<L>,
    ) -> crate::percent::PercentDisplay<L>
    where
        Self: crate::percent::PercentLike,
    {
        crate::percent::percent_with(self, options)
    }
}

impl<T> Humanize for T {}