fedimint-util-error 0.11.0-alpha

fedimint-util-error provides error formatting utilities for the Fedimint ecosystem.
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

use std::fmt::Formatter;
use std::{error, fmt};

/// A wrapper with `fmt::Display` for any `E : Error` that will print chain
/// of causes
pub struct FmtErrorCompact<'e, E>(pub &'e E);

impl<E> fmt::Display for FmtErrorCompact<'_, E>
where
    E: error::Error,
{
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        let mut source_opt: Option<&dyn std::error::Error> = Some(self.0);

        while source_opt.is_some() {
            let source = source_opt.take().expect("Just checked");
            f.write_fmt(format_args!("{source}"))?;

            source_opt = source.source();
            if source_opt.is_some() {
                f.write_str(": ")?;
            }
        }
        Ok(())
    }
}

/// A wrapper with `fmt::Display` for [`anyhow::Error`] that will print
/// chain of causes
pub struct FmtCompactErrorAnyhow<'e>(pub &'e anyhow::Error);

impl fmt::Display for FmtCompactErrorAnyhow<'_> {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        // <https://docs.rs/anyhow/latest/anyhow/struct.Error.html#display-representations>
        f.write_fmt(format_args!("{:#}", self.0))
    }
}

/// Simple utility trait to print error chains
pub trait FmtCompact<'a> {
    type Report: fmt::Display + 'a;
    fn fmt_compact(self) -> Self::Report;
}

/// Simple utility trait to print error chains (for [`anyhow::Error`])
pub trait FmtCompactAnyhow<'a> {
    type Report: fmt::Display + 'a;
    fn fmt_compact_anyhow(self) -> Self::Report;
}

impl<'e, E> FmtCompact<'e> for &'e E
where
    E: error::Error,
{
    type Report = FmtErrorCompact<'e, E>;

    fn fmt_compact(self) -> Self::Report {
        FmtErrorCompact(self)
    }
}

impl<'e> FmtCompactAnyhow<'e> for &'e anyhow::Error {
    type Report = FmtCompactErrorAnyhow<'e>;

    fn fmt_compact_anyhow(self) -> Self::Report {
        FmtCompactErrorAnyhow(self)
    }
}

/// A wrapper with `fmt::Display` for `Result<T, E>` where `E: Error` that
/// prints the error chain on `Err` or `-` on `Ok`
pub struct FmtCompactResultDisplay<'a, T, E>(pub &'a Result<T, E>);

impl<T, E: error::Error> fmt::Display for FmtCompactResultDisplay<'_, T, E> {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self.0 {
            Ok(_) => f.write_str("-"),
            Err(e) => FmtErrorCompact(e).fmt(f),
        }
    }
}

/// A wrapper with `fmt::Display` for `Result<T, anyhow::Error>` that
/// prints the error chain on `Err` or `-` on `Ok`
pub struct FmtCompactResultAnyhowDisplay<'a, T>(pub &'a Result<T, anyhow::Error>);

impl<T> fmt::Display for FmtCompactResultAnyhowDisplay<'_, T> {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self.0 {
            Ok(_) => f.write_str("-"),
            Err(e) => FmtCompactErrorAnyhow(e).fmt(f),
        }
    }
}

/// Extension trait to format `Result<T, E>` compactly (for `E: Error`)
pub trait FmtCompactResult<'a> {
    type Report: fmt::Display + 'a;
    fn fmt_compact_result(&'a self) -> Self::Report;
}

/// Extension trait to format `Result<T, anyhow::Error>` compactly
pub trait FmtCompactResultAnyhow<'a> {
    type Report: fmt::Display + 'a;
    fn fmt_compact_result_anyhow(&'a self) -> Self::Report;
}

impl<'a, T, E> FmtCompactResult<'a> for Result<T, E>
where
    E: error::Error + 'a,
    T: 'a,
{
    type Report = FmtCompactResultDisplay<'a, T, E>;

    fn fmt_compact_result(&'a self) -> Self::Report {
        FmtCompactResultDisplay(self)
    }
}

impl<'a, T: 'a> FmtCompactResultAnyhow<'a> for Result<T, anyhow::Error> {
    type Report = FmtCompactResultAnyhowDisplay<'a, T>;

    fn fmt_compact_result_anyhow(&'a self) -> Self::Report {
        FmtCompactResultAnyhowDisplay(self)
    }
}

#[cfg(test)]
mod test;