yield-return 0.2.0

Implement a coroutine like C#'s `yield return` using Rust's `async`, `await`.
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

use std::{ptr::null, time::Duration};

use futures::StreamExt;
use rt_local::runtime::core::test;
use utils::sleep;
use yield_return::LocalAsyncIter;

mod utils;

#[test]
async fn no_value() {
    let iter = LocalAsyncIter::<u32>::new(|mut _y| async move {});
    let list: Vec<_> = iter.collect().await;
    assert_eq!(list, vec![]);
}

#[test]
async fn values() {
    let iter = LocalAsyncIter::new(|mut y| async move {
        y.ret(1).await;
        y.ret(2).await;
    });
    let list: Vec<_> = iter.collect().await;
    assert_eq!(list, vec![1, 2]);
}

#[test]
async fn values_ret_iter() {
    let iter = LocalAsyncIter::new(|mut y| async move {
        y.ret_iter([1, 2]).await;
    });
    let list: Vec<_> = iter.collect().await;
    assert_eq!(list, vec![1, 2]);
}

#[test]
async fn fused() {
    let mut iter = LocalAsyncIter::new(|mut y| async move {
        y.ret(1).await;
        y.ret(2).await;
    });
    assert_eq!(iter.next().await, Some(1));
    assert_eq!(iter.next().await, Some(2));
    assert_eq!(iter.next().await, None);
    assert_eq!(iter.next().await, None);
}

#[test]
async fn values_with_lifetime() {
    let items = vec![1, 2];
    let items = &items;
    let iter = LocalAsyncIter::new(|mut y| async move {
        y.ret(&items[0]).await;
        y.ret(&items[1]).await;
    });
    let list: Vec<&i32> = iter.collect().await;
    assert_eq!(list, vec![&1, &2]);
}

#[test]
async fn use_sleep() {
    let iter = LocalAsyncIter::<u32>::new(|mut y| async move {
        y.ret(1).await;
        sleep(Duration::from_millis(100)).await;
        y.ret(2).await;
    });
    let list: Vec<_> = iter.collect().await;
    assert_eq!(list, vec![1, 2]);
}

#[test]
#[allow(unused_must_use)]
#[should_panic]
async fn no_await_1() {
    let iter = LocalAsyncIter::new(|mut y| async move {
        y.ret(1);
    });
    let _: Vec<_> = iter.collect().await;
}

#[test]
#[allow(unused_must_use)]
#[should_panic]
async fn no_await_2() {
    let iter = LocalAsyncIter::new(|mut y| async move {
        y.ret(1);
        y.ret(2);
    });
    let _: Vec<_> = iter.collect().await;
}

#[test]
async fn check_not_send() {
    struct NotSend(#[allow(unused)] *const ());
    impl Drop for NotSend {
        fn drop(&mut self) {}
    }
    let iter = LocalAsyncIter::new(|mut y| async move {
        let _not_send = NotSend(null());
        y.ret(1).await;
        y.ret(2).await;
    });
    let list: Vec<_> = iter.collect().await;
    assert_eq!(list, vec![1, 2]);
}