moro 0.4.0

Experimental structured concurrency support for async Rust (similar to trio's nurseries)
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

use std::pin::Pin;

use crate::prelude::*;
use crate::Scope;
use futures::Future;

pub struct Spawned<F> {
    f: F,
}

impl<F> Spawned<F> {
    pub(crate) fn new(f: F) -> Self {
        Self { f }
    }
}

impl<F> Future for Spawned<F>
where
    F: Future,
{
    type Output = F::Output;

    fn poll(
        self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Self::Output> {
        unsafe {
            let f = Pin::new_unchecked(&mut self.get_unchecked_mut().f);
            F::poll(f, cx)
        }
    }
}

impl<F, O, E> Spawned<F>
where
    F: Future<Output = Result<O, E>> + Send,
    O: Send,
    E: Send,
{
    pub fn or_cancel<'scope, 'env, T>(
        self,
        scope: &'scope Scope<'scope, 'env, Result<T, E>>,
    ) -> impl Future<Output = O> + 'scope
    where
        T: Send,
        O: 'scope,
        F: 'scope,
    {
        scope.spawn(async { self.await.unwrap_or_cancel(scope).await })
    }
}