reorg

.gitignore

···
 !rustfmt.toml
 !/futures/
 !/futures/**
+!/futures-*/
+!/futures-*/**

Cargo.lock

···
 version = 4
 
 [[package]]
-name = "futures"
+name = "futures-combinators"
+version = "0.1.0"
+dependencies = [
+ "futures-core",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-core"
 version = "0.1.0"
+
+[[package]]
+name = "futures-util"
+version = "0.1.0"
+dependencies = [
+ "futures-core",
+]

Cargo.toml

···
 [workspace]
 resolver = "3"
-members = [ "futures" ]
+members = [ "futures-combinators", "futures-core", "futures-util"]
 
 [workspace.package]
 version = "0.1.0"

futures-combinators/Cargo.toml

···
+[package]
+name = "futures-combinators"
+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 = { path = "../futures-core" }
+futures-util = { path = "../futures-util" }

futures-combinators/src/lib.rs

···
+mod join;

futures-core/Cargo.toml

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

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 = { path = "../futures-core" }

futures-util/src/lib.rs

···
+mod maybe_done;
+
+use futures_core::ScopedFuture;
+pub use maybe_done::*;
+
+// Just a helper function to ensure the futures we're returning all have the
+// right implementations.
+pub(crate) fn assert_future<'scope, T, F>(future: F) -> F
+where
+    F: ScopedFuture<'scope, Output = T>,
+{
+    future
+}

futures/src/combinators/join.rs futures-combinators/src/join.rs

···
-use crate::{
-    future::{ScopedFuture, Wake},
-    utils::{MaybeDone, maybe_done},
-};
+use futures_core::{ScopedFuture, Wake};
+use futures_util::{MaybeDone, maybe_done};
 use std::mem;
 use std::{pin::Pin, sync::atomic::Ordering};
 use std::{sync::atomic::AtomicBool, task::Poll};
···
     /// This function returns a new future which polls all futures concurrently.
     fn join(self) -> Self::Future;
 }
+
 struct WakeStore<'scope> {
     parent: Option<&'scope dyn Wake<'scope>>,
     ready: AtomicBool,
 }
+
 impl<'scope> WakeStore<'scope> {
     fn new() -> Self {
         Self {
···
         self.ready.swap(false, Ordering::SeqCst)
     }
 }
+
 impl<'scope> Wake<'scope> for WakeStore<'scope> {
     fn wake(&self) {
         self.ready.swap(true, Ordering::SeqCst);

futures/src/future.rs futures-core/src/lib.rs

···
 /// what occurs in `core::task::Future::poll()` is that the ref to a cx.waker
 /// is cloned and stored by a reactor via some method.
 ///
-///
 /// The waker is no longer tied to the actual future's lifetime, making it
 /// unsound to not have either static tasks or reference counting.
 /// To avoid this, we want to use a &'scope waker instead, with 1 waker / task.
-///
-/// If waker is ownable/cloneable, that erases the lifetime's importance.
-/// If the waker is a non clonable mutable reference that lives for 'scope,
-/// it cannot be passed into `poll` every time the future is polled, instead it
-/// must only be registered once, leading to a register_waker api that is very
-/// cumbersome without unsafe poll/unsafe register_waker. Instead, it's easier
-/// to use a non clonable immutable reference and have waking occur via
-/// interior mutability (this is fine since combinators rely on interior
-/// mutability anyway for a 1 parent : many children waker relationship)
 pub trait ScopedFuture<'scope> {
     type Output;
 

futures/src/utils/maybe_done.rs futures-util/src/maybe_done.rs

···
 //! Definition of the MaybeDone combinator
 
-use crate::future::{ScopedFuture, Wake};
+use futures_core::{ScopedFuture, Wake};
 
 use super::assert_future;
 use core::mem;