fixed remaining join and race test cases

Cargo.lock

···
 ]
 
 [[package]]
-name = "futures"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
-dependencies = [
- "futures-channel",
- "futures-core 0.3.31",
- "futures-executor",
- "futures-io",
- "futures-sink",
- "futures-task",
- "futures-util",
-]
-
-[[package]]
-name = "futures-channel"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
-dependencies = [
- "futures-core 0.3.31",
- "futures-sink",
-]
-
-[[package]]
 name = "futures-combinators"
 version = "0.0.2"
 dependencies = [
- "futures 0.3.31",
  "futures-compat",
- "futures-core 0.0.2",
+ "futures-core",
+ "futures-util",
  "lifetime-guard",
 ]
 
···
 name = "futures-compat"
 version = "0.0.2"
 dependencies = [
- "futures-core 0.0.2",
+ "futures-core",
  "lifetime-guard",
 ]
 
···
 version = "0.0.2"
 
 [[package]]
-name = "futures-core"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
-
-[[package]]
 name = "futures-derive"
 version = "0.0.2"
 dependencies = [
···
 ]
 
 [[package]]
-name = "futures-executor"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
-dependencies = [
- "futures-core 0.3.31",
- "futures-task",
- "futures-util",
-]
-
-[[package]]
-name = "futures-io"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
-
-[[package]]
-name = "futures-macro"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "futures-sink"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
-
-[[package]]
-name = "futures-task"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
-
-[[package]]
 name = "futures-util"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
+version = "0.0.2"
 dependencies = [
- "futures-channel",
- "futures-core 0.3.31",
- "futures-io",
- "futures-macro",
- "futures-sink",
- "futures-task",
- "memchr",
- "pin-project-lite",
- "pin-utils",
- "slab",
+ "futures-core",
+ "lifetime-guard",
 ]
 
 [[package]]
···
 checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
 
 [[package]]
-name = "pin-utils"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
-
-[[package]]
 name = "proc-macro2"
 version = "1.0.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
-
-[[package]]
-name = "slab"
-version = "0.4.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
 
 [[package]]
 name = "smallvec"

Cargo.toml

···
 [workspace]
 resolver = "3"
-members = [ "futures", "futures-combinators", "futures-compat", "futures-core", "futures-derive", "lifetime-guard"]
+members = [ "futures", "futures-combinators", "futures-compat", "futures-core", "futures-derive", "futures-util", "lifetime-guard"]
 
 [workspace.package]
 version = "0.0.2"
···
 futures-compat = { path = "futures-compat", version = "0.0.2" }
 futures-core = { path = "futures-core", version = "0.0.2" }
 futures-derive = { path = "futures-derive", version = "0.0.2" }
+futures-util = { path = "futures-util", version = "0.0.2" }
 lifetime-guard = { path = "lifetime-guard", version = "0.0.2" }
-# TODO probably vendor in
-futures = "0.3"

futures-combinators/src/join.rs

···
 mod tests {
     #![no_std]
 
-    use futures_core::{Future, Wake};
-    use lifetime_guard::guard::ValueGuard;
+    use futures_core::Future;
 
-    use crate::wake::{DummyWaker, local_wake, poll_fn};
+    use crate::wake::{dummy_guard, local_wake, poll_fn};
 
     use super::*;
 
     use std::pin;
-    use std::ptr::NonNull;
 
     #[test]
     fn counters() {
···
                 Poll::Pending
             }
         });
-        let guard = pin::pin!(ValueGuard::new(NonNull::new(
-            &mut DummyWaker as *mut dyn Wake,
-        )));
-        let join = (f1, f2).join();
-        let mut pinned = pin::pin!(join);
+        let guard = pin::pin!(dummy_guard());
+        let mut join = pin::pin!((f1, f2).join());
         for _ in 0..4 {
-            assert_eq!(pinned.as_mut().poll(guard.as_ref()), Poll::Pending);
+            assert_eq!(join.as_mut().poll(guard.as_ref()), Poll::Pending);
         }
-        assert_eq!(pinned.poll(guard.as_ref()), Poll::Ready((4, 5)));
+        assert_eq!(join.poll(guard.as_ref()), Poll::Ready((4, 5)));
     }
 
-    // #[test]
-    // fn never_wake() {
-    //     let f1 = poll_fn(|_| Poll::<i32>::Pending);
-    //     let f2 = poll_fn(|_| Poll::<i32>::Pending);
-    //     let dummy_waker = noop_wake();
-    //     let join = (f1, f2).join();
-    //     for _ in 0..10 {
-    //         assert_eq!(join.poll(&dummy_waker), Poll::Pending);
-    //     }
-    // }
+    #[test]
+    fn never_wake() {
+        let f1 = poll_fn(|_| Poll::<i32>::Ready(0));
+        let f2 = poll_fn(|_| Poll::<i32>::Pending);
+        let guard = pin::pin!(dummy_guard());
+        let mut join = pin::pin!((f1, f2).join());
+        for _ in 0..10 {
+            assert_eq!(join.as_mut().poll(guard.as_ref()), Poll::Pending);
+        }
+    }
 
-    // #[test]
-    // fn basic() {
-    //     let f1 = poll_fn(|_| Poll::Ready(1));
-    //     let f2 = poll_fn(|_| Poll::Ready(2));
-    //     let dummy_waker = noop_wake();
-    //     assert_eq!(f1.along_with(f2).poll(&dummy_waker), Poll::Ready((1, 2)));
-    // }
+    #[test]
+    fn immediate() {
+        let f1 = poll_fn(|_| Poll::Ready(1));
+        let f2 = poll_fn(|_| Poll::Ready(2));
+        let join = pin::pin!(f1.along_with(f2));
+        let guard = pin::pin!(dummy_guard());
+        assert_eq!(join.poll(guard.as_ref()), Poll::Ready((1, 2)));
+    }
 }

futures-combinators/src/race.rs

···
 
 use crate::wake::WakeArray;
 use std::pin::Pin;
-use std::task::Context;
-use std::{cell::Cell, task::Poll};
+use std::task::Poll;
 
 /// from [futures-concurrency](https://github.com/yoshuawuyts/futures-concurrency/tree/main)
 /// Wait for the first future to complete.
···
 mod tests {
     #![no_std]
 
-    use std::{pin, ptr::NonNull};
+    use std::pin;
 
-    use futures_core::{Future, Wake};
-    use lifetime_guard::guard::ValueGuard;
+    use futures_core::Future;
 
-    use crate::wake::{DummyWaker, local_wake, poll_fn};
+    use crate::wake::{dummy_guard, local_wake, poll_fn};
 
     use super::*;
 
···
                 Poll::Pending
             }
         });
-        let guard = pin::pin!(ValueGuard::new(NonNull::new(
-            &mut DummyWaker as *mut dyn Wake,
-        )));
-        let join = (f1, f2).race();
-        let mut pinned = pin::pin!(join);
-        assert_eq!(pinned.as_mut().poll(guard.as_ref()), Poll::Pending);
-        assert_eq!(
-            pinned.poll(guard.as_ref()),
-            Poll::Ready(RaceOutputs2::B(2))
-        );
+        let guard = pin::pin!(dummy_guard());
+        let mut race = pin::pin!((f1, f2).race());
+        assert_eq!(race.as_mut().poll(guard.as_ref()), Poll::Pending);
+        assert_eq!(race.poll(guard.as_ref()), Poll::Ready(RaceOutputs2::B(2)));
     }
 
-    // #[test]
-    // fn never_wake() {
-    //     let f1 = poll_fn(|_| Poll::<i32>::Pending);
-    //     let f2 = poll_fn(|_| Poll::<i32>::Pending);
-    //     let dummy_waker = noop_wake();
-    //     let join = (f1, f2).race();
-    //     for _ in 0..10 {
-    //         assert_eq!(join.poll(&dummy_waker), Poll::Pending);
-    //     }
-    // }
+    #[test]
+    fn never_wake() {
+        let f1 = poll_fn(|_| Poll::<i32>::Pending);
+        let f2 = poll_fn(|_| Poll::<i32>::Pending);
+        let mut race = pin::pin!((f1, f2).race());
+        let guard = pin::pin!(dummy_guard());
+        for _ in 0..10 {
+            assert_eq!(race.as_mut().poll(guard.as_ref()), Poll::Pending);
+        }
+    }
 
-    // #[test]
-    // fn basic() {
-    //     let f1 = poll_fn(|_| Poll::Ready(1));
-    //     let f2 = poll_fn(|_| Poll::Ready(2));
-    //     let dummy_waker = noop_wake();
-    //     assert_eq!(
-    //         f1.race_with(f2).poll(&dummy_waker),
-    //         Poll::Ready(RaceOutputs2::A(1))
-    //     );
-    // }
+    #[test]
+    fn basic() {
+        let f1 = poll_fn(|_| Poll::Ready(1));
+        let f2 = poll_fn(|_| Poll::Ready(2));
+        let race = pin::pin!(f1.race_with(f2));
+        let guard = pin::pin!(dummy_guard());
+        assert_eq!(race.poll(guard.as_ref()), Poll::Ready(RaceOutputs2::A(1)));
+    }
 }

futures-combinators/src/wake.rs

···
         dbg!("awake!");
     }
 }
+
+pub fn dummy_guard() -> ValueGuard<WakePtr> {
+    ValueGuard::new(NonNull::new(&mut DummyWaker as *mut dyn Wake))
+}

futures-compat/src/lib.rs

···
 //! with an executor/reactor intended for bcsc::Future is strictly unsound.
 
 use std::{
+    hint::unreachable_unchecked,
     mem::ManuallyDrop,
     pin::Pin,
     ptr::NonNull,
···
 use futures_core::Wake;
 use lifetime_guard::{atomic_guard::AtomicValueGuard, guard::ValueGuard};
 
-static EVIL_VTABLE: RawWakerVTable = RawWakerVTable::new(
-    |_| panic!("wtf"),
-    |_| panic!("wtf"),
-    |_| panic!("wtf"),
-    |_| panic!("wtf"),
-);
-
 pub type WakePtr = Option<NonNull<dyn Wake>>;
+pub type LocalWaker = ValueGuard<WakePtr>;
+pub type AtomicWaker = AtomicValueGuard<WakePtr>;
+
+static EVIL_VTABLE: RawWakerVTable = unsafe {
+    RawWakerVTable::new(
+        |_| unreachable_unchecked(),
+        |_| unreachable_unchecked(),
+        |_| unreachable_unchecked(),
+        |_| unreachable_unchecked(),
+    )
+};
 
 /// Coerces a pinned `ValueGuard` reference to a `Waker` for use in
 /// `core::future::Future`
 ///
 /// Any usage or storage of the resulting `Waker` is undefined behavior.
-pub unsafe fn guard_to_waker(
-    guard: Pin<&ValueGuard<WakePtr>>,
-) -> ManuallyDrop<Waker> {
+pub unsafe fn guard_to_waker(guard: Pin<&LocalWaker>) -> ManuallyDrop<Waker> {
     ManuallyDrop::new(unsafe {
         Waker::from_raw(RawWaker::new(
             guard.get_ref() as *const ValueGuard<WakePtr> as *const (),
···
         ))
     })
 }
+
 pub unsafe fn atomic_guard_to_waker(
-    guard: Pin<&AtomicValueGuard<WakePtr>>,
-) -> Waker {
-    unsafe {
+    guard: Pin<&AtomicWaker>,
+) -> ManuallyDrop<Waker> {
+    ManuallyDrop::new(unsafe {
         Waker::from_raw(RawWaker::new(
             guard.get_ref() as *const AtomicValueGuard<WakePtr> as *const (),
             &EVIL_VTABLE,
         ))
-    }
+    })
 }
 
 /// Coerces a `Waker` into a pinned `AtomicValueGuard` reference.
 ///
 /// This should only be used to undo the work of `guard_to_waker`.
-pub unsafe fn waker_to_guard<'a>(
-    waker: &Waker,
-) -> Pin<&'a ValueGuard<WakePtr>> {
+pub unsafe fn waker_to_guard<'a>(waker: &Waker) -> Pin<&LocalWaker> {
     unsafe {
         Pin::new_unchecked(&*(waker.data() as *const ValueGuard<WakePtr>))
     }
 }
-pub unsafe fn waker_to_atomic_guard<'a>(
-    waker: &Waker,
-) -> Pin<&'a AtomicValueGuard<WakePtr>> {
+
+pub unsafe fn waker_to_atomic_guard<'a>(waker: &Waker) -> Pin<&AtomicWaker> {
     unsafe {
         Pin::new_unchecked(&*(waker.data() as *const AtomicValueGuard<WakePtr>))
     }
 }
 
-// TODO should probably return impl futures_core::Future, same for next fn
 pub unsafe fn std_future_to_bespoke<F: core::future::Future>(
     future: F,
-) -> NormalFutureWrapper<F> {
+) -> impl futures_core::Future<LocalWaker, Output = F::Output> {
     NormalFutureWrapper(future)
 }
 
-pub unsafe fn bespoke_future_to_std<F: futures_core::Future>(
+pub unsafe fn bespoke_future_to_std<F: futures_core::Future<LocalWaker>>(
     future: F,
-) -> BespokeFutureWrapper<F> {
+) -> impl core::future::Future<Output = F::Output> {
     BespokeFutureWrapper(future)
 }
 
···
 #[repr(transparent)]
 pub struct NormalFutureWrapper<F: core::future::Future>(F);
 
-impl<F: core::future::Future> futures_core::Future for NormalFutureWrapper<F> {
+impl<F: core::future::Future> futures_core::Future<LocalWaker>
+    for NormalFutureWrapper<F>
+{
     type Output = F::Output;
 
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        unsafe { self.map_unchecked_mut(|this| &mut this.0).poll(cx) }
+    fn poll(
+        self: Pin<&mut Self>,
+        waker: Pin<&LocalWaker>,
+    ) -> Poll<Self::Output> {
+        unsafe {
+            self.map_unchecked_mut(|this| &mut this.0)
+                .poll(&mut Context::from_waker(&guard_to_waker(waker)))
+        }
     }
 }
 
 /// wraps custom `bcsc::Future` in impl of `core::future::Future`
 #[repr(transparent)]
-pub struct BespokeFutureWrapper<F: futures_core::Future>(F);
+pub struct BespokeFutureWrapper<F>(F)
+where
+    F: futures_core::Future<LocalWaker>;
 
-impl<F: futures_core::Future> core::future::Future for BespokeFutureWrapper<F> {
+impl<F> core::future::Future for BespokeFutureWrapper<F>
+where
+    F: futures_core::Future<LocalWaker>,
+{
     type Output = F::Output;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        unsafe { self.map_unchecked_mut(|this| &mut this.0).poll(cx) }
+        unsafe {
+            self.map_unchecked_mut(|this| &mut this.0)
+                .poll(waker_to_guard(cx.waker()))
+        }
     }
 }
+
+// impl<F> core::future::Future for F
+// where
+//     F: for<'a> futures_core::Future<Context<'a>>,
+// {
+//     type Output = F::Output;
+
+//     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+//         self.poll(cx.waker())
+//     }
+// }
 
 #[cfg(test)]
 mod test {

futures-core/src/lib.rs

···
 //! Redefinitions of task::Future to be incompatible with them
 
 use std::{
-    ops,
+    ops::{self, DerefMut},
     pin::Pin,
-    task::{Context, Poll},
+    task::Poll,
 };
 
 /// A future represents an asynchronous computation obtained by use of `async`.
···
     message = "`{Self}` is not a `bcsc::Future`",
     note = "If you are trying to await a `core::future::Future` from within a `bcsc::Future`, note that the systems are incompatible."
 )]
-pub trait Future {
+pub trait Future<Waker> {
     /// The type of value produced on completion.
     type Output;
 
···
     /// [`Poll::Ready(val)`]: Poll::Ready
     /// [`Waker`]: crate::task::Waker
     /// [`Waker::wake`]: crate::task::Waker::wake
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
+    fn poll(self: Pin<&mut Self>, waker: Pin<&Waker>) -> Poll<Self::Output>;
 }
 
-impl<F: ?Sized + Future + Unpin> Future for &mut F {
+impl<Waker, F: ?Sized + Future<Waker> + Unpin> Future<Waker> for &mut F {
     type Output = F::Output;
 
     fn poll(
         mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
+        waker: Pin<&Waker>,
     ) -> Poll<Self::Output> {
-        F::poll(Pin::new(&mut **self), cx)
+        F::poll(Pin::new(&mut **self), waker)
     }
 }
 
-impl<P> Future for Pin<P>
+impl<Waker, P> Future<Waker> for Pin<P>
 where
-    P: ops::DerefMut<Target: Future>,
+    P: ops::DerefMut<Target: Future<Waker>>,
+{
+    type Output = <<P as ops::Deref>::Target as Future<Waker>>::Output;
+
+    fn poll(self: Pin<&mut Self>, waker: Pin<&Waker>) -> Poll<Self::Output> {
+        <P::Target as Future<Waker>>::poll(self.as_deref_mut(), waker)
+    }
+}
+
+/// A future which tracks whether or not the underlying future
+/// should no longer be polled.
+///
+/// `is_terminated` will return `true` if a future should no longer be polled.
+/// Usually, this state occurs after `poll` (or `try_poll`) returned
+/// `Poll::Ready`. However, `is_terminated` may also return `true` if a future
+/// has become inactive and can no longer make progress and should be ignored
+/// or dropped rather than being `poll`ed again.
+pub trait FusedFuture<Waker>: Future<Waker> {
+    /// Returns `true` if the underlying future should no longer be polled.
+    fn is_terminated(&self) -> bool;
+}
+
+impl<Waker, F: FusedFuture<Waker> + ?Sized + Unpin> FusedFuture<Waker>
+    for &mut F
 {
-    type Output = <<P as ops::Deref>::Target as Future>::Output;
+    fn is_terminated(&self) -> bool {
+        <F as FusedFuture<Waker>>::is_terminated(&**self)
+    }
+}
 
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        <P::Target as Future>::poll(self.as_deref_mut(), cx)
+impl<Waker, P> FusedFuture<Waker> for Pin<P>
+where
+    P: DerefMut + Unpin,
+    P::Target: FusedFuture<Waker>,
+{
+    fn is_terminated(&self) -> bool {
+        <P::Target as FusedFuture<Waker>>::is_terminated(&**self)
     }
 }
 

futures-util/Cargo.toml

···
+[package]
+name = "futures-util"
+version.workspace = true
+rust-version.workspace = true
+edition.workspace = true
+license.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+
+[dependencies]
+futures-core = { workspace = true }
+lifetime-guard = { workspace = true }

futures-util/src/lib.rs

···
+use std::ptr::NonNull;
+
+use futures_core::{Future, Wake};
+use lifetime_guard::{atomic_guard::AtomicValueGuard, guard::ValueGuard};
+
+pub mod maybe_done;
+
+pub type WakePtr = Option<NonNull<dyn Wake>>;
+pub type LocalWaker = ValueGuard<WakePtr>;
+pub type AtomicWaker = AtomicValueGuard<WakePtr>;
+
+pub(crate) fn assert_future<T, F>(future: F) -> F
+where
+    F: Future<LocalWaker, Output = T>,
+{
+    future
+}

futures-util/src/maybe_done.rs

···
+//! Definition of the MaybeDone combinator
+
+use futures_core::FusedFuture;
+
+use crate::LocalWaker;
+
+use super::assert_future;
+use core::mem;
+use core::pin::Pin;
+use futures_core::Future;
+use std::task::Poll;
+use std::task::ready;
+
+/// A future that may have completed.
+///
+/// This is created by the [`maybe_done()`] function.
+#[derive(Debug)]
+pub enum MaybeDone<Fut: Future<LocalWaker>> {
+    /// A not-yet-completed future
+    Future(/* #[pin] */ Fut),
+    /// The output of the completed future
+    Done(Fut::Output),
+    /// The empty variant after the result of a [`MaybeDone`] has been
+    /// taken using the [`take_output`](MaybeDone::take_output) method.
+    Gone,
+}
+
+impl<Fut: Future<LocalWaker> + Unpin> Unpin for MaybeDone<Fut> {}
+
+/// Wraps a future into a `MaybeDone`
+///
+/// # Examples
+///
+/// ```
+/// # futures::executor::block_on(async {
+/// use core::pin::pin;
+///
+/// use futures::future;
+///
+/// let future = future::maybe_done(async { 5 });
+/// let mut future = pin!(future);
+/// assert_eq!(future.as_mut().take_output(), None);
+/// let () = future.as_mut().await;
+/// assert_eq!(future.as_mut().take_output(), Some(5));
+/// assert_eq!(future.as_mut().take_output(), None);
+/// # });
+/// ```
+pub fn maybe_done<Fut: Future<LocalWaker>>(future: Fut) -> MaybeDone<Fut> {
+    assert_future::<(), _>(MaybeDone::Future(future))
+}
+
+impl<Fut: Future<LocalWaker>> MaybeDone<Fut> {
+    /// Returns an [`Option`] containing a mutable reference to the output of the future.
+    /// The output of this method will be [`Some`] if and only if the inner
+    /// future has been completed and [`take_output`](MaybeDone::take_output)
+    /// has not yet been called.
+    #[inline]
+    pub fn output_mut(self: Pin<&mut Self>) -> Option<&mut Fut::Output> {
+        unsafe {
+            match self.get_unchecked_mut() {
+                Self::Done(res) => Some(res),
+                _ => None,
+            }
+        }
+    }
+
+    /// Attempt to take the output of a `MaybeDone` without driving it
+    /// towards completion.
+    #[inline]
+    pub fn take_output(self: Pin<&mut Self>) -> Option<Fut::Output> {
+        match &*self {
+            Self::Done(_) => {}
+            Self::Future(_) | Self::Gone => return None,
+        }
+        unsafe {
+            match mem::replace(self.get_unchecked_mut(), Self::Gone) {
+                Self::Done(output) => Some(output),
+                _ => unreachable!(),
+            }
+        }
+    }
+}
+
+impl<Fut: Future<LocalWaker>> FusedFuture<LocalWaker> for MaybeDone<Fut> {
+    fn is_terminated(&self) -> bool {
+        match self {
+            Self::Future(_) => false,
+            Self::Done(_) | Self::Gone => true,
+        }
+    }
+}
+
+impl<Fut: Future<LocalWaker>> Future<LocalWaker> for MaybeDone<Fut> {
+    type Output = ();
+
+    fn poll(
+        mut self: Pin<&mut Self>,
+        waker: Pin<&LocalWaker>,
+    ) -> Poll<Self::Output> {
+        unsafe {
+            match self.as_mut().get_unchecked_mut() {
+                Self::Future(f) => {
+                    let res = ready!(Pin::new_unchecked(f).poll(waker));
+                    self.set(Self::Done(res));
+                }
+                Self::Done(_) => {}
+                Self::Gone => panic!("MaybeDone polled after value taken"),
+            }
+        }
+        Poll::Ready(())
+    }
+}