doublysure 0.1.0

Using types to make sure that you're sure, sure, and doubly sure
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

#![cfg(test)]

use crate::*;

#[test]
fn new() {
    AreYouSure::new(1);
}

#[test]
fn value() {
    assert_eq!(
        AreYouSure::new(2).yes_i_am_sure(),
        2
    );
}

#[test]
fn value_macro() {
    let x = make_sure!(3);
    assert_eq!(
        x.yes_i_am_sure(),
        3
    );
}

#[test]
fn deferred_macro() {
    use std::cmp::min;
    let x = make_sure!(min(4, 5));
    assert_eq!(
        x.yes_i_am_sure(),
        4
    );
}

#[test]
fn deferred_namespaced() {
    let x = make_sure!(std::cmp::min(4, 5));
    assert_eq!(
        x.yes_i_am_sure(),
        4
    );
}

#[test]
fn deferred_method() {
    let mut v = Vec::new();
    let x = make_sure!(v.push(5));
    x.yes_i_am_sure();
    assert_eq!(
        v,
        vec![5]
    );
}

fn sideeffecting(val: usize) -> usize {
        println!("{}", val);
        val
}

#[test]
fn deferred_sideffects_macro() {
    let x = make_sure!(sideeffecting(6));
    assert_eq!(
        x.yes_i_am_sure(),
        6
    );
}

#[test]
fn block_deferred_macro() {
    let x = make_sure!({
        let y = 7;
        println!("{}", y);
        y
    });
    assert_eq!(
        x.yes_i_am_sure(),
        7
    );
}

#[test]
fn value_macro_chain() {
    assert_eq!(
        make_sure!(8).yes_i_am_sure(),
        8
    )
}