refactored futues_core::Future, futures_compat, added race back

futures-combinators/Cargo.toml

···
 [dependencies]
 futures-core = { workspace = true }
 futures-compat = { workspace = true }
+futures-util = { workspace = true }
 lifetime-guard = { workspace = true }
-futures = { workspace = true }

futures-combinators/src/join.rs

···
 use crate::wake::WakeArray;
-use futures::future::FusedFuture;
-use futures::future::MaybeDone;
-use futures::future::maybe_done;
-use futures_compat::BespokeFutureWrapper;
+use futures_compat::LocalWaker;
+use futures_core::FusedFuture;
+use futures_util::maybe_done::MaybeDone;
+use futures_util::maybe_done::maybe_done;
 use std::pin::Pin;
-use std::task::Context;
 use std::task::Poll;
 
 /// from [futures-concurrency](https://github.com/yoshuawuyts/futures-concurrency/tree/main)
···
     type Output;
 
     /// The [`ScopedFuture`] implementation returned by this method.
-    type Future: futures_core::Future<Output = Self::Output>;
+    type Future: futures_core::Future<LocalWaker, Output = Self::Output>;
 
     /// Waits for multiple futures to complete.
     ///
···
 pub trait JoinExt {
     fn along_with<Fut>(self, other: Fut) -> Join2<Self, Fut>
     where
-        Self: Sized + futures_core::Future,
-        Fut: futures_core::Future,
+        Self: Sized + futures_core::Future<LocalWaker>,
+        Fut: futures_core::Future<LocalWaker>,
     {
         (self, other).join()
     }
 }
 
-impl<T> JoinExt for T where T: futures_core::Future {}
+impl<T> JoinExt for T where T: futures_core::Future<LocalWaker> {}
 
 macro_rules! impl_join_tuple {
     ($namespace:ident $StructName:ident $($F:ident)+) => {
···
 
         #[allow(non_snake_case)]
         #[must_use = "futures do nothing unless you `.await` or poll them"]
-        pub struct $StructName<$($F: futures_core::Future),+> {
-            $($F: MaybeDone<BespokeFutureWrapper<$F>>,)*
+        pub struct $StructName<$($F: futures_core::Future<LocalWaker>),+> {
+            $($F: MaybeDone<$F>,)*
             wake_array: WakeArray<{$namespace::LEN}>,
         }
 
-        impl<$($F: futures_core::Future),+> futures_core::Future for $StructName<$($F),+>
+        impl<$($F: futures_core::Future<LocalWaker>),+> futures_core::Future<LocalWaker> for $StructName<$($F),+>
         {
             type Output = ($($F::Output),+);
 
             #[allow(non_snake_case)]
-            fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+            fn poll(self: Pin<&mut Self>, waker: Pin<&LocalWaker>) -> Poll<Self::Output> {
                 let this = unsafe { self.get_unchecked_mut() };
 
                 let wake_array = unsafe { Pin::new_unchecked(&this.wake_array) };
···
                     let mut $F = unsafe { Pin::new_unchecked(&mut this.$F) };
                 )+
 
-                // extract reference to ValueGuard from Context
-                // this is safe because futures_core::Future are isolated
-                // from core::future::Future impls and guaranteed to have
-                // their cx.wakers represented in the nonstandard format
-                wake_array.register_parent(unsafe { futures_compat::waker_to_guard(cx.waker()) });
+                wake_array.register_parent(waker);
 
                 let mut ready = true;
 
                 $(
                     let index = $namespace::Indexes::$F as usize;
-                    // cx to feed children
-                    let waker = unsafe { futures_compat::guard_to_waker(wake_array.child_guard_ptr(index).unwrap_unchecked()) };
-                    let mut child_cx = Context::from_waker(&waker);
+                    let waker = unsafe { wake_array.child_guard_ptr(index).unwrap_unchecked() };
 
                     // ready if MaybeDone is Done or just completed (converted to Done)
                     // unsafe / against Future api contract to poll after Gone/Future is finished
                     ready &= if unsafe { dbg!(wake_array.take_woken(index).unwrap_unchecked()) } {
-                        $F.as_mut().poll(&mut child_cx).is_ready()
+                        $F.as_mut().poll(waker).is_ready()
                     } else {
                         $F.is_terminated()
                     };
···
             }
         }
 
-        impl<$($F: futures_core::Future),+> Join for ($($F),+) {
+        impl<$($F: futures_core::Future<LocalWaker>),+> Join for ($($F),+) {
             type Output = ($($F::Output),*);
             type Future = $StructName<$($F),+>;
 
···
                 let ($($F),+) = self;
 
                 $StructName {
-                    $($F: maybe_done(unsafe { futures_compat::bespoke_future_to_std($F) }),)*
+                    $($F: maybe_done($F),)*
                     wake_array: WakeArray::new(),
                 }
             }
···
     use futures_core::{Future, Wake};
     use lifetime_guard::guard::ValueGuard;
 
-    use crate::wake::{DummyWaker, wake_bespoke_waker};
+    use crate::wake::{DummyWaker, local_wake, poll_fn};
 
     use super::*;
 
-    use std::future::poll_fn;
     use std::pin;
     use std::ptr::NonNull;
 
···
     fn counters() {
         let mut x1 = 0;
         let mut x2 = 0;
-        let f1 = poll_fn(|cx| {
-            unsafe { wake_bespoke_waker(cx.waker()) };
+        let f1 = poll_fn(|waker| {
+            local_wake(waker);
             x1 += 1;
             if x1 == 4 {
                 Poll::Ready(x1)
···
                 Poll::Pending
             }
         });
-        let f2 = poll_fn(|cx| {
-            unsafe { wake_bespoke_waker(cx.waker()) };
+        let f2 = poll_fn(|waker| {
+            local_wake(waker);
             x2 += 1;
             if x2 == 5 {
                 Poll::Ready(x2)
···
         let guard = pin::pin!(ValueGuard::new(NonNull::new(
             &mut DummyWaker as *mut dyn Wake,
         )));
-        let waker = unsafe { futures_compat::guard_to_waker(guard.as_ref()) };
-        let mut cx = Context::from_waker(&waker);
-        let mut join = unsafe {
-            (
-                futures_compat::std_future_to_bespoke(f1),
-                futures_compat::std_future_to_bespoke(f2),
-            )
-        }
-        .join();
+        let join = (f1, f2).join();
         let mut pinned = pin::pin!(join);
         for _ in 0..4 {
-            assert_eq!(pinned.as_mut().poll(&mut cx), Poll::Pending);
+            assert_eq!(pinned.as_mut().poll(guard.as_ref()), Poll::Pending);
         }
-        assert_eq!(pinned.poll(&mut cx), Poll::Ready((4, 5)));
+        assert_eq!(pinned.poll(guard.as_ref()), Poll::Ready((4, 5)));
     }
 
     // #[test]

futures-combinators/src/lib.rs

···
 pub mod join;
-// pub mod race;
+pub mod race;
 mod wake;
 
 use join::*;
-// use race::*;
+use race::*;

futures-combinators/src/race.rs

···
-use futures_core::{ScopedFuture, Wake};
-use futures_util::WakeStore;
+use futures_util::LocalWaker;
+
+use crate::wake::WakeArray;
+use std::pin::Pin;
+use std::task::Context;
 use std::{cell::Cell, task::Poll};
 
 /// from [futures-concurrency](https://github.com/yoshuawuyts/futures-concurrency/tree/main)
···
 ///
 /// Awaits multiple future at once, returning as soon as one completes. The
 /// other futures are cancelled.
-pub trait Race<'scope> {
+pub trait Race {
     /// The resulting output type.
     type Output;
 
     /// The [`ScopedFuture`] implementation returned by this method.
-    type Future: ScopedFuture<'scope, Output = Self::Output>;
+    type Future: futures_core::Future<LocalWaker, Output = Self::Output>;
 
     /// Wait for the first future to complete.
     ///
···
 }
 
 pub trait RaceExt<'scope> {
-    fn race_with<Fut>(self, other: Fut) -> Race2<'scope, Self, Fut>
+    fn race_with<Fut>(self, other: Fut) -> Race2<Self, Fut>
     where
-        Self: Sized + 'scope + ScopedFuture<'scope>,
-        Fut: ScopedFuture<'scope> + 'scope,
+        Self: Sized + futures_core::Future<LocalWaker>,
+        Fut: futures_core::Future<LocalWaker>,
     {
         (self, other).race()
     }
 }
 
-impl<'scope, T> RaceExt<'scope> for T where T: ScopedFuture<'scope> {}
+impl<'scope, T> RaceExt<'scope> for T where T: futures_core::Future<LocalWaker> {}
 
 macro_rules! impl_race_tuple {
     ($namespace:ident $StructName:ident $OutputsName:ident $($F:ident)+) => {
         mod $namespace {
-            use super::*;
-
-            #[allow(non_snake_case)]
-            pub struct Wakers<'scope> {
-                $(pub $F: WakeStore<'scope>,)*
-            }
-
-            #[allow(non_snake_case)]
-            pub struct WakerRefs<'scope> {
-                $(pub $F: Cell<Option<&'scope dyn Wake<'scope>>>,)*
-            }
+            #[repr(u8)]
+            pub(super) enum Indexes { $($F,)+ }
+            pub(super) const LEN: usize = [$(Indexes::$F,)+].len();
         }
 
         pub enum $OutputsName<$($F,)+> {
···
 
         #[allow(non_snake_case)]
         #[must_use = "futures do nothing unless you `.await` or poll them"]
-        pub struct $StructName<'scope, $($F: ScopedFuture<'scope>),+> {
+        pub struct $StructName<$($F: futures_core::Future<LocalWaker>),+> {
             $($F: $F,)*
-            wakers: $namespace::Wakers<'scope>,
-            refs: $namespace::WakerRefs<'scope>,
+            wake_array: WakeArray<{$namespace::LEN}>,
         }
 
-        impl<'scope, $($F: ScopedFuture<'scope> + 'scope),+> ScopedFuture<'scope>
-            for $StructName<'scope, $($F),+>
+        impl<'scope, $($F: futures_core::Future<LocalWaker>),+> futures_core::Future<LocalWaker>
+            for $StructName<$($F),+>
         {
             type Output = $OutputsName<$($F::Output,)+>;
 
-            fn poll(&'scope self, wake: &'scope dyn Wake<'scope>) -> Poll<Self::Output> {
+            #[allow(non_snake_case)]
+            fn poll(self: Pin<&mut Self>, waker: Pin<&LocalWaker>) -> Poll<Self::Output> {
+                let this = unsafe { self.get_unchecked_mut() };
+
+                let wake_array = unsafe { Pin::new_unchecked(&this.wake_array) };
                 $(
-                    self.wakers.$F.set_parent(wake);
-                    self.refs.$F.replace(Some(&self.wakers.$F));
+                    let mut $F = unsafe { Pin::new_unchecked(&mut this.$F) };
+                )+
 
-                    if self.wakers.$F.take_ready() {
-                        // By polling the future, we create our self-referential structure for lifetime `'scope`.
-                        //
-                        // SAFETY:
-                        // `unwrap_unchecked` is safe because we just inserted `Some` into `refs.$F`,
-                        // so it is guaranteed to be `Some`.
-                        if let Poll::Ready(res) = self.$F.poll(unsafe { (&self.refs.$F.get()).unwrap_unchecked() }) {
+                wake_array.register_parent(waker);
+
+                $(
+                    let index = $namespace::Indexes::$F as usize;
+                    let waker = unsafe { wake_array.child_guard_ptr(index).unwrap_unchecked() };
+
+                    // this is safe because we know index < LEN
+                    if unsafe { wake_array.take_woken(index).unwrap_unchecked() } {
+                        if let Poll::Ready(res) = $F.as_mut().poll(waker) {
                             return Poll::Ready($OutputsName::$F(res));
                         }
                     }
···
             }
         }
 
-        impl<'scope, $($F: ScopedFuture<'scope> + 'scope),+> Race<'scope> for ($($F),+) {
+        impl<'scope, $($F: futures_core::Future<LocalWaker>),+> Race for ($($F),+) {
             type Output = $OutputsName<$($F::Output),*>;
-            type Future = $StructName<'scope, $($F),+>;
+            type Future = $StructName<$($F),+>;
 
             #[allow(non_snake_case)]
             fn race(self) -> Self::Future {
···
 
                 $StructName {
                     $($F: $F,)*
-                    wakers: $namespace::Wakers {
-                        $($F: WakeStore::new(),)*
-                    },
-                    refs: $namespace::WakerRefs {
-                        $($F: Option::None.into(),)*
-                    },
+                    wake_array: WakeArray::new(),
                 }
             }
         }
···
 mod tests {
     #![no_std]
 
-    use futures_util::{noop_wake, poll_fn};
+    use std::{pin, ptr::NonNull};
+
+    use futures_core::{Future, Wake};
+    use lifetime_guard::guard::ValueGuard;
+
+    use crate::wake::{DummyWaker, local_wake, poll_fn};
 
     use super::*;
 
     #[test]
     fn counters() {
-        let x1 = Cell::new(0);
-        let x2 = Cell::new(0);
-        let f1 = poll_fn(|wake| {
-            wake.wake();
-            x1.set(x1.get() + 1);
-            if x1.get() == 4 {
-                Poll::Ready(x1.get())
+        let mut x1 = 0;
+        let mut x2 = 0;
+        let f1 = poll_fn(|waker| {
+            local_wake(waker);
+            x1 += 1;
+            if x1 == 4 {
+                Poll::Ready(x1)
             } else {
                 Poll::Pending
             }
         });
-        let f2 = poll_fn(|wake| {
-            wake.wake();
-            x2.set(x2.get() + 1);
-            if x2.get() == 2 {
-                Poll::Ready(x2.get())
+        let f2 = poll_fn(|waker| {
+            local_wake(waker);
+            x2 += 1;
+            if x2 == 2 {
+                Poll::Ready(x2)
             } else {
                 Poll::Pending
             }
         });
-        let dummy_waker = noop_wake();
+        let guard = pin::pin!(ValueGuard::new(NonNull::new(
+            &mut DummyWaker as *mut dyn Wake,
+        )));
         let join = (f1, f2).race();
-        assert_eq!(join.poll(&dummy_waker), Poll::Pending);
-        assert_eq!(join.poll(&dummy_waker), Poll::Ready(RaceOutputs2::B(2)));
+        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))
+        );
     }
 
-    #[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 dummy_waker = noop_wake();
+    //     let join = (f1, f2).race();
+    //     for _ in 0..10 {
+    //         assert_eq!(join.poll(&dummy_waker), 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 dummy_waker = noop_wake();
+    //     assert_eq!(
+    //         f1.race_with(f2).poll(&dummy_waker),
+    //         Poll::Ready(RaceOutputs2::A(1))
+    //     );
+    // }
 }

futures-combinators/src/wake.rs

···
-use std::{array, cell::Cell, marker::PhantomPinned, pin::Pin, ptr::NonNull};
+use std::{
+    array, cell::Cell, marker::PhantomPinned, pin::Pin, ptr::NonNull,
+    task::Poll,
+};
 
-use futures_compat::WakePtr;
+use futures_compat::{LocalWaker, WakePtr};
 use futures_core::Wake;
 use lifetime_guard::{guard::RefGuard, guard::ValueGuard};
 
···
     }
 }
 
-pub unsafe fn wake_bespoke_waker(waker: &std::task::Waker) {
-    unsafe {
-        let guard = futures_compat::waker_to_guard(waker);
-        if let Some(wake) = guard.get() {
-            (*wake.as_ptr()).wake();
-        }
+pub fn local_wake(guard: &LocalWaker) {
+    if let Some(wake) = guard.get() {
+        unsafe { (*wake.as_ptr()).wake() }
+    }
+}
+
+// pub unsafe fn wake_bespoke_waker(waker: &std::task::Waker) {
+//     unsafe {
+//         let guard = futures_compat::waker_to_guard(waker);
+//         if let Some(wake) = guard.get() {
+//             (*wake.as_ptr()).wake();
+//         }
+//     }
+// }
+
+pub struct PollFn<F, T>(F)
+where
+    F: FnMut(&LocalWaker) -> Poll<T>;
+
+impl<F, T> futures_core::Future<LocalWaker> for PollFn<F, T>
+where
+    F: FnMut(&LocalWaker) -> Poll<T>,
+{
+    type Output = T;
+
+    fn poll(
+        self: Pin<&mut Self>,
+        waker: Pin<&LocalWaker>,
+    ) -> Poll<Self::Output> {
+        (unsafe { &mut self.get_unchecked_mut().0 })(&waker)
     }
+}
+
+pub fn poll_fn<F, T>(f: F) -> impl futures_core::Future<LocalWaker, Output = T>
+where
+    F: FnMut(&LocalWaker) -> Poll<T>,
+{
+    PollFn(f)
 }
 
 pub struct DummyWaker;