flowcontrol 0.2.3

Utilities for clarifying and simplifying control flow
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

/// A break shed. This defines a stopping point for `break` in the enclosed code,
/// as if you had wrapped it in `loop {}`.
///
/// Use like:
///
/// ```rust
/// shed!{
///     ...
///     break;
/// }
/// ```
///
/// or, labeled:
///
/// ```rust
/// shed!{
///     'x _;
///     ...
///     break 'x;
/// }
/// ```
#[macro_export]
macro_rules! shed{
    // With a break label, like `bb!{ 'label _; ... }`
    ($l: lifetime _; $($t: tt) *) => {
        $l: loop {
            #[allow(unreachable_code)] break {
                $($t) *
            };
        }
    };
    // No label, `bb!{ ... }`
    ($($t: tt) *) => {
        loop {
            #[allow(unreachable_code)] break {
                $($t) *
            };
        }
    };
}

/// Execute the second block where the first block breaks with the label, like the
/// first block is a giant `if` condition.
///
/// Use like:
///
/// ```rust
/// superif!({
///     ...
///     break 'then;
/// } 'then {
///     ...
/// });
/// ```
///
/// If the first block exits without breaking to the label the 2nd block won't be
/// entered.
///
/// There's an alternative form if you want to pass data from the conditional block:
///
/// ```rust
/// superif!({
///     ...
///     break 'then 39;
/// } data = 'then {
///     println!("{}", data);
/// });
/// ```
#[macro_export]
macro_rules! superif{
    ({
        $($t: tt) *
    } $l: lifetime {
        $($t2: tt) *
    }) => {
        $crate:: superif !({
            $($t) *
        } _unused = $l {
            $($t2) *
        })
    };
    ({
        $($t: tt) *
    } $i: ident = $l: lifetime {
        $($t2: tt) *
    }) => {
        $crate:: shed ! {
            'superif _;
            // Condition
            let $i = $crate:: shed ! {
                $l _;
                break 'superif $crate:: shed ! {
                    $($t) *
                };
            };
            // Else
            $($t2) *
        }
    }
}

#[test]
fn test_superif() {
    superif!({
        if true {
            break 'then;
        }
    } 'then {
    });
}

/// Type-assert return type: explicitly communicate the `Ok` return type for the
/// block to the compiler via unreachable code.
///
/// Use like `ta_return!(i32, MyError);`
#[macro_export]
macro_rules! ta_return{
    ($t: ty, $e: ty) => {
        if false {
            fn unreachable_value<T>() -> T {
                panic!();
            }
            return std:: result:: Result::< $t,
            $e >:: Ok(unreachable_value());
        }
    }
}

/// Convert an enum to an option:
///
/// Use like
/// `let (x, y, z) = exenum!(res, MyEnum::Value(x, y, z) => (x, y, z)).unwrap()`.
#[macro_export]
macro_rules! exenum{
    ($s: expr, $m: pat => $v: expr) => {
        match $s {
            $m => Some($v),
            _ => None,
        }
    }
}