floop 0.2.1

A more convenient and less error prone replacement for loop `{ select! { .. }}`
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

use std::{future::ready, time::Duration};

use floop::floop;
use smol::{Timer, block_on, future::poll_once};

#[test]
fn return_() {
    assert_eq!(block_on(return_32()), 32);
}

async fn return_32() -> i32 {
    let mut counter = 2;

    let result = floop!{
        unbiased
        return
        _ in Timer::after(Duration::from_millis(34)) => {
            counter *= 2;
        }
        _ in ready(()) => {
            break "foo";
        }
        _ in Timer::after(Duration::from_millis(41)) => {
            if counter == 32 {
                return counter;
            }
        }
    };

    let _: &str = result.1;
    match result.0 {}
}

#[test]
fn return_break() {
    let fut = async |i: i32| {
        floop!{
            biased
            return
            _ in Timer::after(Duration::from_millis(10)) => {
                if i == 5 {
                    return "return";
                } else {
                    break;
                }
            }
            () in ready(()) => {
                break "break";
            }
        }.1
    };

    block_on(async {
        assert_eq!(fut(5).await, "return");
        assert_eq!(fut(10).await, "break");
    })
}

#[test]
fn return_empty() {
    let fut = async {
        floop! {
            biased
            return
        }
    };

    assert_eq!(block_on(poll_once(fut)), Some(()));
}