errlanes 0.18.1

Four error lanes (Rejected/Denied/Transient/Fatal) carried in the type, not re-derived at every layer
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

use errlanes::{
    Denied, Fail, Fault, WithDenied, WithFatal, WithTransient, WithoutDenied, WithoutTransient,
    lanes,
};

type MyFault = Fault<lanes!(Transient, Fatal)>;
type MyFail = Fail<Nope, lanes!(Transient, Fatal)>;

#[derive(Debug, errlanes::Rejection)]
#[rejection(code = "nope")]
#[error("nope")]
pub struct Nope;

#[derive(Debug, errlanes::Carrier)]
pub enum HostFault {
    Transient(errlanes::Transient),
    Fatal(errlanes::Fatal),
}

fn base() -> Result<(), MyFault> {
    Ok(())
}
fn host() -> Result<(), HostFault> {
    Ok(())
}

fn may_deny(deny: bool) -> Result<(), WithDenied<MyFault>> {
    base()?;
    if deny {
        return Err(Fault::Denied(Denied::new()));
    }
    Ok(())
}
fn host_may_deny() -> Result<(), WithDenied<HostFault>> {
    host()?;
    Err(Denied::new().into())
}
fn fail_may_deny() -> Result<(), WithDenied<MyFail>> {
    Err(Fail::Rejected(Nope))
}

fn no_transient(f: WithoutTransient<MyFault>) -> Fault<lanes!(Fatal)> {
    f
}
fn round_trip(f: WithoutDenied<WithDenied<MyFault>>) -> MyFault {
    f
}
fn add_transient(f: WithTransient<Fault<lanes!(Fatal)>>) -> MyFault {
    f
}
fn add_fatal(f: WithFatal<Fault<lanes!(Transient)>>) -> MyFault {
    f
}
fn on_profile(f: Fault<WithoutTransient<lanes!(Transient, Fatal)>>) -> Fault<lanes!(Fatal)> {
    f
}
fn on_carrier(f: WithoutTransient<HostFault>) -> Fault<lanes!(Fatal)> {
    f
}
fn exhaustive(f: WithDenied<MyFault>) -> &'static str {
    match f {
        Fault::Denied(_) => "denied",
        Fault::Transient(_) => "transient",
        Fault::Fatal(_) => "fatal",
    }
}
fn generic<E: errlanes::Reshape>(e: E::WithDenied) -> WithDenied<E> {
    e
}

#[test]
fn reshape_aliases() {
    may_deny(false).unwrap();
    assert!(may_deny(true).unwrap_err().is_denied());
    assert!(host_may_deny().unwrap_err().is_denied());
    assert!(fail_may_deny().is_err());
    assert_eq!(exhaustive(Fault::Denied(Denied::new())), "denied");
    let _ = (
        no_transient,
        round_trip,
        add_transient,
        add_fatal,
        on_profile,
        on_carrier,
        generic::<MyFault>,
    );
}