iex 0.2.0

Idiomatic exceptions
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

use iex::{iex, Outcome};

#[iex]
fn produces_err() -> Result<(), String> {
    Err("Hello,".to_string())
}

#[iex]
fn maps_err() -> Result<(), String> {
    produces_err().map_err(|e| format!("{e} world!"))
}

#[test]
fn simple() {
    assert_eq!(maps_err().into_result().unwrap_err(), "Hello, world!");
}

#[iex]
fn produces_err2(s: &str) -> Result<i32, &'static str> {
    Err(&*s.to_string().leak())
}

#[iex]
fn maps_err_owned() -> Result<i32, String> {
    let s1 = "Hello,".to_string();
    Ok(produces_err2(&mut s1).map_err(
        #[iex(shares = s1)]
        |e| {
            let _s1: String = s1;
            format!("{e} world!")
        },
    )?)
}

#[test]
fn shares() {
    assert_eq!(maps_err_owned().into_result().unwrap_err(), "Hello, world!");
}

struct A;

impl A {
    #[iex]
    fn produces_err(&mut self) -> Result<(), ()> {
        Err(())
    }

    #[iex]
    fn maps_err_owned(self) -> Result<(), ()> {
        Ok(self.produces_err().map_err(
            #[iex(shares = self)]
            |_| {
                let _self: A = self;
            },
        )?)
    }
}

#[iex]
fn maps_err_mut_ref(mut a: A) -> Result<(), ()> {
    let ar = &mut a;
    ar.produces_err().map_err(
        #[iex(shares = ar)]
        |_| {
            let _ar: &mut A = ar;
        },
    )?;
    drop(a);
    Ok(())
}

#[test]
fn owned_method() {
    assert_eq!(A.maps_err_owned().into_result(), Err(()));
}

#[test]
fn mut_ref() {
    assert_eq!(maps_err_mut_ref(A).into_result(), Err(()));
}