par-stream 0.10.2

Asynchronous parallel streams analogous to rayon
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

use crate::common::*;
use tokio::runtime::{Handle, Runtime};

pub fn spawn<F>(future: F) -> JoinHandle<F::Output>
where
    F: 'static + Future + Send,
    F::Output: 'static + Send,
{
    JoinHandle(tokio::spawn(future))
}

pub fn spawn_blocking<F, R>(f: F) -> JoinHandle<R>
where
    F: 'static + Send + FnOnce() -> R,
    R: 'static + Send,
{
    JoinHandle(tokio::task::spawn_blocking(f))
}

pub async fn sleep(duration: Duration) {
    tokio::time::sleep(duration).await;
}

pub fn block_on<F>(future: F) -> F::Output
where
    F: Future,
{
    Handle::current().block_on(future)
}

pub fn block_on_executor<F>(future: F) -> F::Output
where
    F: Future,
{
    Runtime::new().unwrap().block_on(future)
}

pub struct JoinHandle<T>(tokio::task::JoinHandle<T>);

impl<T> Future for JoinHandle<T> {
    type Output = T;

    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        Pin::new(&mut self.0).poll(cx).map(|result| result.unwrap())
    }
}