error-forge 0.9.7

A comprehensive Rust error management framework with async support, error recovery patterns, and resilience features for building robust, fault-tolerant applications with rich error handling, formatting, and tracing capabilities.
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

use std::fmt;

#[derive(Debug)]
pub enum MyError {
    Config { message: String },
    Filesystem { path: String, error: String },
    Crash { reason: String },
}

impl MyError {
    pub fn config(msg: impl Into<String>) -> Self {
        MyError::Config {
            message: msg.into(),
        }
    }

    pub fn caption(&self) -> &'static str {
        match self {
            Self::Config { .. } => "⚙️ Config",
            Self::Filesystem { .. } => "💾 IO",
            Self::Crash { .. } => "🚨 Panic",
        }
    }

    pub fn is_retryable(&self) -> bool {
        matches!(self, Self::Filesystem { .. })
    }

    pub fn exit_code(&self) -> i32 {
        match self {
            Self::Config { .. } => 78,
            _ => 1,
        }
    }
}

impl fmt::Display for MyError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            MyError::Config { message } => write!(f, "⚙️ Config: {}", message),
            MyError::Filesystem { path, error } => write!(f, "💾 IO at {}: {}", path, error),
            MyError::Crash { reason } => write!(f, "🚨 Panic: {}", reason),
        }
    }
}

fn fail() -> Result<(), MyError> {
    Err(MyError::config("Missing database URL"))
}

fn main() {
    match fail() {
        Ok(_) => println!("✅ All good!"),
        Err(e) => {
            eprintln!("❌ {}", e);
            eprintln!("↳ Caption: {}", e.caption());
            eprintln!("↳ Retryable: {}", e.is_retryable());
            eprintln!("↳ Exit Code: {}", e.exit_code());
            std::process::exit(e.exit_code());
        }
    }
}