tcio 0.1.0

Collection of utility types.
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

use std::{pin::Pin, task::ready};

/// Map a [`Future`] output into another [`Future`].
///
/// # Example
///
/// ```
/// # async fn app() {
/// use tcio::futures::then;
/// let fut = async { 112 };
/// let result = then(fut, |e| async move { e.to_string() }).await;
/// assert_eq!(&result[..], "112");
/// # }
/// # assert!(matches!(
/// #     std::pin::pin!(app())
/// #         .poll(&mut std::task::Context::from_waker(std::task::Waker::noop())),
/// #     std::task::Poll::Ready(())
/// # ));
/// ```
#[inline]
pub fn then<F, M, F2>(f: F, map: M) -> Then<F, M, F2>
where
    F: Future,
    M: FnOnce(F::Output) -> F2,
    F2: Future,
{
    Then { phase: Phase::F1(f), map: Some(map) }
}

/// Future returned by [`then`].
#[derive(Debug)]
pub struct Then<F, M, F2> {
    phase: Phase<F, F2>,
    map: Option<M>,
}

#[derive(Debug)]
enum Phase<F, F2> {
    F1(F),
    F2(F2),
}

impl<F, M, F2> Future for Then<F, M, F2>
where
    F: Future,
    M: FnOnce(F::Output) -> F2,
    F2: Future,
{
    type Output = F2::Output;

    #[inline]
    fn poll(
        mut self: Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Self::Output> {
        // SAFETY: self is pinned
        // no `Drop`, nor manual `Unpin` implementation.
        let me = unsafe { self.as_mut().get_unchecked_mut() };

        match &mut me.phase {
            Phase::F1(f) => {
                // SAFETY: self is pinned
                // no `Drop`, nor manual `Unpin` implementation.
                let f = unsafe { Pin::new_unchecked(f) };
                let ok = ready!(f.poll(cx));
                let ok = me.map.take().expect("poll after complete")(ok);
                me.phase = Phase::F2(ok);
                self.poll(cx)
            }
            // SAFETY: self is pinned
            // no `Drop`, nor manual `Unpin` implementation.
            Phase::F2(f) => unsafe { Pin::new_unchecked(f) }.poll(cx),
        }
    }
}