humfmt 0.6.0

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

/// Extension trait providing ergonomic `.human_*()` methods.
///
/// This trait is implemented for **all** types via a blanket impl
/// (`impl<T> Humanize for T {}`), but each method is only available when the
/// receiver implements the corresponding `*Like` trait (`BytesLike`,
/// `NumberLike`, etc.) — enforced via per-method `where` bounds.
///
/// This is a deliberate API design choice: the blanket impl keeps the import
/// surface tiny (`use humfmt::Humanize;` brings everything in), while the
/// `where` bounds keep the methods type-safe — calling
/// `"hello".human_number()` is a compile error, not a runtime surprise.
///
/// # Examples
///
/// ```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.
    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(self, options: crate::duration::DurationOptions) -> crate::ago::AgoDisplay
    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(
        self,
        options: crate::duration::DurationOptions,
    ) -> crate::duration::DurationDisplay
    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
    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(
        self,
        options: crate::number::NumberOptions,
    ) -> crate::number::NumberDisplay
    where
        Self: crate::number::NumberLike,
    {
        crate::number::number_with(self, options)
    }

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

    /// 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
    where
        Self: crate::percent::PercentLike,
    {
        crate::percent::percent(self)
    }

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

impl<T> Humanize for T {}