go 0.1.2

A runtime-agnostic Go-style concurrency library for Rust
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

/// `select!` macro that multiplexes multiple channel recv operations.
///
/// Supports 1-3 recv branches plus an optional `default` non-blocking branch.
/// Runtime-agnostic: uses `poll_fn` internally, no backend dependency.
///
/// # Examples
///
/// ```ignore
/// select! {
///     v = rx1.recv() => { /* use v */ },
///     _ = rx2.recv() => { ... },
///     default => { ... },
/// }
/// ```
#[macro_export]
macro_rules! select {
    // Recursive accumulator: all branches consumed, no default
    (@ [$($arms:tt)*]) => {
        $crate::__select_impl!($($arms)* ; no_default)
    };
    // Recursive accumulator: hit the `default` terminator
    (@ [$($arms:tt)*] default => $default:expr $(,)?) => {
        $crate::__select_impl!($($arms)* ; default { $default })
    };
    // Recursive accumulator: consume one branch and continue
    (@ [$($arms:tt)*] $var:pat = $fut:expr => $body:expr, $($rest:tt)*) => {
        $crate::select!(@ [$($arms)* $var = $fut => $body,] $($rest)*)
    };
    // Recursive accumulator: last branch (no trailing comma), no default
    (@ [$($arms:tt)*] $var:pat = $fut:expr => $body:expr) => {
        $crate::__select_impl!($($arms)* $var = $fut => $body, ; no_default)
    };
    // Entry point
    ($($input:tt)*) => {
        $crate::select!(@ [] $($input)*)
    };
}

#[macro_export]
#[doc(hidden)]
macro_rules! __select_impl {
    // Single branch, no default (just await it)
    ($v1:pat = $f1:expr => $b1:expr, ; no_default) => {{
        let $v1 = $f1.await;
        $b1
    }};
    // Single branch + default
    ($v1:pat = $f1:expr => $b1:expr, ; default { $default:expr }) => {{
        let mut f1 = core::pin::pin!($f1);
        ::futures_lite::future::poll_fn(|cx| {
            if let core::task::Poll::Ready(v) = f1.as_mut().poll(cx) {
                let $v1 = v;
                return core::task::Poll::Ready($b1);
            }
            core::task::Poll::Ready($default)
        })
        .await
    }};
    // Two branches, no default
    ($v1:pat = $f1:expr => $b1:expr, $v2:pat = $f2:expr => $b2:expr, ; no_default) => {{
        let mut f1 = core::pin::pin!($f1);
        let mut f2 = core::pin::pin!($f2);
        ::futures_lite::future::poll_fn(|cx| {
            if let core::task::Poll::Ready(v) = f1.as_mut().poll(cx) {
                let $v1 = v;
                return core::task::Poll::Ready($b1);
            }
            if let core::task::Poll::Ready(v) = f2.as_mut().poll(cx) {
                let $v2 = v;
                return core::task::Poll::Ready($b2);
            }
            core::task::Poll::Pending
        })
        .await
    }};
    // Two branches + default
    ($v1:pat = $f1:expr => $b1:expr, $v2:pat = $f2:expr => $b2:expr, ; default { $default:expr }) => {{
        let mut f1 = core::pin::pin!($f1);
        let mut f2 = core::pin::pin!($f2);
        ::futures_lite::future::poll_fn(|cx| {
            if let core::task::Poll::Ready(v) = f1.as_mut().poll(cx) {
                let $v1 = v;
                return core::task::Poll::Ready($b1);
            }
            if let core::task::Poll::Ready(v) = f2.as_mut().poll(cx) {
                let $v2 = v;
                return core::task::Poll::Ready($b2);
            }
            core::task::Poll::Ready($default)
        })
        .await
    }};
    // Three branches, no default
    ($v1:pat = $f1:expr => $b1:expr, $v2:pat = $f2:expr => $b2:expr, $v3:pat = $f3:expr => $b3:expr, ; no_default) => {{
        let mut f1 = core::pin::pin!($f1);
        let mut f2 = core::pin::pin!($f2);
        let mut f3 = core::pin::pin!($f3);
        ::futures_lite::future::poll_fn(|cx| {
            if let core::task::Poll::Ready(v) = f1.as_mut().poll(cx) {
                let $v1 = v;
                return core::task::Poll::Ready($b1);
            }
            if let core::task::Poll::Ready(v) = f2.as_mut().poll(cx) {
                let $v2 = v;
                return core::task::Poll::Ready($b2);
            }
            if let core::task::Poll::Ready(v) = f3.as_mut().poll(cx) {
                let $v3 = v;
                return core::task::Poll::Ready($b3);
            }
            core::task::Poll::Pending
        })
        .await
    }};
    // Three branches + default
    ($v1:pat = $f1:expr => $b1:expr, $v2:pat = $f2:expr => $b2:expr, $v3:pat = $f3:expr => $b3:expr, ; default { $default:expr }) => {{
        let mut f1 = core::pin::pin!($f1);
        let mut f2 = core::pin::pin!($f2);
        let mut f3 = core::pin::pin!($f3);
        ::futures_lite::future::poll_fn(|cx| {
            if let core::task::Poll::Ready(v) = f1.as_mut().poll(cx) {
                let $v1 = v;
                return core::task::Poll::Ready($b1);
            }
            if let core::task::Poll::Ready(v) = f2.as_mut().poll(cx) {
                let $v2 = v;
                return core::task::Poll::Ready($b2);
            }
            if let core::task::Poll::Ready(v) = f3.as_mut().poll(cx) {
                let $v3 = v;
                return core::task::Poll::Ready($b3);
            }
            core::task::Poll::Ready($default)
        })
        .await
    }};
}