formatted?

.gitignore

···
 !flake.nix
 !rust-toolchain.toml
 !README.md
+!rustfmt.toml
 !/futures/
 !/futures/**

futures/src/combinators/join.rs

···
 use std::mem;
 use std::{pin::Pin, sync::atomic::Ordering};
 use std::{sync::atomic::AtomicBool, task::Poll};
-
 /// from yoshuawuyts/futures-concurrency
 /// Wait for all futures to complete.
 ///
···
 pub trait Join<'scope> {
     /// The resulting output type.
     type Output;
-
     /// The [`Future`] implementation returned by this method.
     type Future: ScopedFuture<'scope, Output = Self::Output>;
-
     /// Waits for multiple futures to complete.
     ///
     /// Awaits multiple futures simultaneously, returning the output of the futures
···
     /// This function returns a new future which polls all futures concurrently.
     fn join(self) -> Self::Future;
 }
-
-// "look at what they need for a fraction of our power" (more efficient join impl is regular join here)
-// https://github.com/yoshuawuyts/futures-concurrency/blob/main/src/utils/wakers/array/waker.rs
-// possibly copy large portions of futures-concurrency over here
-
-// struct Waker<'scope> {
-//     parent_waker: Wake<'scope>,
-// }
-
-// impl<'scope> Waker<'scope> {
-//     fn wake(&mut self) {
-//         (*self.parent_waker)();
-//     }
-// }
-
-// /// implements unsafe logic for a set of wakers waking one waker
-// pub struct WakerArray<'scope, const N: usize> {
-//     parent_waker: Option<&'scope dyn Wake<'scope>>,
-//     // TODO bit packing
-//     child_readiness: [bool; N],
-//     pub child_wakers: Option<[Waker<'scope>; N]>,
-// }
-
-// impl<'scope, const N: usize> WakerArray<'scope, N> {
-//     fn new() -> Self {
-//         Self {
-//             parent_waker: None,
-//             child_readiness: [false; N],
-//             child_wakers: None,
-//         }
-//     }
-
-// fn register_parent_wake(&mut self, wake: Wake<'scope>) {
-//     self.parent_waker = Some(wake);
-//     self.child_wakers = Some(
-//         [Waker {
-//             parent_waker: &self.parent_waker,
-//         }; N],
-//     );
-// }
-// }
-
-// would be rly nice if rust had java functional interfaces for wake(&mut Self)
-
 struct WakeStore<'scope> {
-    // no extra storage bc None is 0x000 ptr
     parent: Option<&'scope dyn Wake<'scope>>,
     ready: AtomicBool,
 }
-
 impl<'scope> WakeStore<'scope> {
     fn new() -> Self {
         Self {
···
             ready: true.into(),
         }
     }
-
     fn take_ready(&mut self) -> bool {
         self.ready.swap(false, Ordering::SeqCst)
     }
 }
-
 impl<'scope> Wake<'scope> for WakeStore<'scope> {
     fn wake(&self) {
         self.ready.swap(true, Ordering::SeqCst);
···
     }
 }
 
-// heavily based on https://github.com/yoshuawuyts/futures-concurrency
 macro_rules! impl_join_tuple {
     ($StructName:ident $($F:ident)+) => {
-
-        // this exists to work around concatenating idents
-        // once https://doc.rust-lang.org/stable/unstable-book/language-features/macro-metavar-expr-concat.html is stable, the $StructName can just contain
-        // future_$F and waker_$F
         #[allow(non_snake_case)]
         struct Wakers<'scope> {
-            // inefficient, needs tt muncher for actual [T; LEN] traversal, fewer cache misses
             $($F: WakeStore<'scope>,)*
         }
 
         #[allow(non_snake_case)]
         pub struct $StructName<'scope, $($F: ScopedFuture<'scope>),+> {
-            // parent_waker: Option<&'scope dyn Wake>,
             $($F: MaybeDone<'scope, $F>,)*
             wakers: Wakers<'scope>,
         }
 
-        impl<'scope, $($F: ScopedFuture<'scope> + 'scope),+> ScopedFuture<'scope> for $StructName<'scope, $($F),+>
+        impl<'scope, $($F: ScopedFuture<'scope> + 'scope),+> ScopedFuture<'scope>
+            for $StructName<'scope, $($F),+>
         {
             type Output = ($($F::Output),+);
 
-            fn poll(self: Pin<&mut Self>, wake: &'scope dyn Wake<'scope>) -> Poll<Self::Output>
-            {
+            fn poll(self: Pin<&mut Self>, wake: &'scope dyn Wake<'scope>) -> Poll<Self::Output> {
                 let this = unsafe { self.get_unchecked_mut() };
-
                 let mut ready = true;
 
                 $(
···
                     if let MaybeDone::Future(fut) = &mut this.$F {
                         ready &= if this.wakers.$F.take_ready() {
                             unsafe {
-                                Pin::new_unchecked(fut).poll(mem::transmute(&this.wakers.$F as &dyn Wake)).is_ready()
+                                Pin::new_unchecked(fut).poll(
+                                    mem::transmute::<&dyn Wake<'scope>, &'scope dyn Wake<'scope>>(
+                                        &this.wakers.$F
+                                    )
+                                ).is_ready()
                             }
                         } else {
                             false
···
                 )+
 
                 if ready {
-                    Poll::Ready(($(
-                        // unwrap_unchecked is safe here because we know all
-                        // futures have been polled to completion
-                        // (`MaybeDone::Done`) and have never been converted
-                        // to `MaybeDone::Gone`
-                        unsafe { Pin::new_unchecked(&mut this.$F).take_output().unwrap_unchecked() },
-                    )*))
+                    Poll::Ready((
+                        $(
+                            unsafe {
+                                Pin::new_unchecked(&mut this.$F)
+                                    .take_output()
+                                    .unwrap_unchecked()
+                            },
+                        )*
+                    ))
                 } else {
                     Poll::Pending
                 }
-
             }
         }
 
···
 
             #[allow(non_snake_case)]
             fn join(self) -> Self::Future {
-                let ($($F),+): ($($F),+) = self;
+                let ($($F),+) = self;
+
                 $StructName {
-                    // parent_waker: Option::None,
                     $($F: maybe_done($F),)*
-                    wakers: Wakers { $($F: WakeStore::new(),)* }
+                    wakers: Wakers { $($F: WakeStore::new(),)* },
                 }
             }
         }

futures/src/future.rs

···
 pub trait ScopedFuture<'scope> {
     type Output;
 
-    fn poll(self: Pin<&mut Self>, wake: &'scope dyn Wake<'scope>) -> Poll<Self::Output>;
+    fn poll(
+        self: Pin<&mut Self>,
+        wake: &'scope dyn Wake<'scope>,
+    ) -> Poll<Self::Output>;
 }

futures/src/lib.rs

···
 mod future;
 mod utils;
 
-use std::{pin::Pin, task::Poll};
-
 /// from yoshuawuyts/futures-concurrency
 /// Wait for all futures to complete.
 ///

futures/src/utils/maybe_done.rs

···
     Gone,
 }
 
-impl<'scope, Fut: ScopedFuture<'scope> + Unpin> Unpin for MaybeDone<'scope, Fut> {}
+impl<'scope, Fut: ScopedFuture<'scope> + Unpin> Unpin
+    for MaybeDone<'scope, Fut>
+{
+}
 
 /// Wraps a future into a `MaybeDone`
 ///
···
 /// assert_eq!(future.as_mut().take_output(), None);
 /// # });
 /// ```
-pub fn maybe_done<'scope, Fut: ScopedFuture<'scope>>(future: Fut) -> MaybeDone<'scope, Fut> {
+pub fn maybe_done<'scope, Fut: ScopedFuture<'scope>>(
+    future: Fut,
+) -> MaybeDone<'scope, Fut> {
     assert_future::<(), _>(MaybeDone::Future(future))
 }
 
···
 //     }
 // }
 
-impl<'scope, Fut: ScopedFuture<'scope>> ScopedFuture<'scope> for MaybeDone<'scope, Fut> {
+impl<'scope, Fut: ScopedFuture<'scope>> ScopedFuture<'scope>
+    for MaybeDone<'scope, Fut>
+{
     type Output = ();
 
-    fn poll(mut self: Pin<&mut Self>, cx: &'scope dyn Wake<'scope>) -> Poll<Self::Output>
+    fn poll(
+        mut self: Pin<&mut Self>,
+        cx: &'scope dyn Wake<'scope>,
+    ) -> Poll<Self::Output>
 // where
     //     'scope: 'react,
     {

rustfmt.toml

···
+max_width = 80