futility 0.1.1

Functional Utility types, macros, and functions for common tasks or needs in 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

use color_eyre::eyre::Report;
use futility::terminate::Terminate;
use std::error::Error;

#[test]
pub fn terminate_eyre() -> Result<(), Report> {
    Terminate::new()
        .at_exit(|| {
            println!("The program is in the process exiting.");
        })
        .on_error(|err: Report| err.wrap_err("We're at the top of main"))
        .execute(|| {
            println!("I'm the actual program and can be both a closure or just a function");
            Ok(())
        })
}

#[test]
pub fn terminate_box_err() -> Result<(), Box<dyn Error>> {
    Terminate::new()
        .at_exit(|| {
            println!("The program is in the process exiting.");
        })
        .on_error(|err: Box<dyn Error>| {
            if let Some(source) = err.source() {
                eprintln!("Lower Level Source Error: {source:?}");
            }
            err
        })
        .execute(|| {
            println!("I'm the actual program and can be both a closure or just a function");
            Ok(())
        })
}

#[test]
pub fn terminate_eyre_named_fn() -> Result<(), Report> {
    Terminate::new()
        .install(install)
        .at_exit(at_exit)
        .on_error(eyre_on_error)
        .execute(execute)
}
#[test]
pub fn terminate_box_err_named_fn() -> Result<(), Box<dyn Error>> {
    Terminate::new()
        .at_exit(at_exit)
        .on_error(box_on_error)
        .execute(execute)
}

fn install() -> Result<(), Report> {
    color_eyre::install()?;
    Ok(())
}

fn eyre_on_error(err: Report) -> Report {
    err.wrap_err("We're at the top of main")
}
fn box_on_error(err: Box<dyn Error>) -> Box<dyn Error> {
    if let Some(source) = err.source() {
        eprintln!("Lower Level Source Error: {source:?}");
    }
    err
}

fn at_exit() {
    println!("The program is in the process exiting.");
}

fn execute<E>() -> Result<(), E> {
    println!("I'm the actual program and can be both a closure or just a function");
    Ok(())
}