iterr 0.2.0

Combinators for dealing with iterators of `Result`s.
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

extern crate iterr;

use iterr::ItErr;

#[test]
fn test_lift_err_1() {
    let elems = vec![Ok(1i32), Ok(2), Err(3i32), Ok(4)]
        .into_iter()
        .lift_err(|inner| inner

            .map(|x| (x*2) as i64)
            .map(|x| Ok::<i64, i32>(x))
        )
        .collect::<Vec<Result<i64, i32>>>();
    assert_eq!(elems, vec![Ok(2i64), Ok(4), Err(3)]);
}

#[test]
fn test_trap_err_1() {
    let mut trap = <_>::default();
    let sum: i32 = vec![Ok(1i32), Ok(2), Err(3i32), Ok(4)]
        .into_iter()
        .trap_err(&mut trap)
        .sum();
    assert_eq!(sum, 3);
    let sum = trap.and_ok(sum);
    assert_eq!(sum, Err(3));
}

#[test]
#[should_panic]
fn test_trap_err_2() {
    let mut trap = <_>::default();
    let sum: i32 = vec![Ok(1i32), Ok(2), Err(3i32), Ok(4)]
        .into_iter()
        .trap_err(&mut trap)
        .sum();
    assert_eq!(sum, 3);
    // Whoops, forgot to check trap!
}

#[test]
fn test_trap_err_3() {
    let mut trap = <_>::default();
    let sum: i32 = vec![Ok(1i32), Ok(2), Err(3i32), Ok(4)]
        .into_iter()
        .trap_err(&mut trap)
        .sum();
    assert_eq!(sum, 3);
    let sum = trap.and_then_ok(|| sum);
    assert_eq!(sum, Err(3));
}

#[test]
fn test_trap_err_4() {
    let mut trap = <_>::default();
    let sum: i32 = vec![Ok(1i32), Ok(2), Err(3i32), Ok(4)]
        .into_iter()
        .trap_err(&mut trap)
        .sum();
    assert_eq!(sum, 3);
    let sum = trap.and(Ok(sum));
    assert_eq!(sum, Err(3));
}

#[test]
fn test_trap_err_5() {
    let mut trap = <_>::default();
    let sum: i32 = vec![Ok(1i32), Ok(2), Err(3i32), Ok(4)]
        .into_iter()
        .trap_err(&mut trap)
        .sum();
    assert_eq!(sum, 3);
    let sum = trap.and_then(|| Ok(sum));
    assert_eq!(sum, Err(3));
}

#[test]
fn test_trap_err_6() {
    let mut trap = <_>::default();
    let sum: i32 = vec![Ok(1i32), Ok(2), Err(3i32), Ok(4)]
        .into_iter()
        .trap_err(&mut trap)
        .sum();
    assert_eq!(sum, 3);
    let sum = trap.into_result().and(Ok(sum));
    assert_eq!(sum, Err(3));
}

#[test]
fn test_trap_err_raw_1() {
    let mut trap = Ok(());
    let sum: i32 = vec![Ok(1i32), Ok(2), Err(3i32), Ok(4)]
        .into_iter()
        .trap_err_raw(&mut trap)
        .sum();
    assert_eq!(trap, Err(3));
    assert_eq!(sum, 3);
}