Core cleanup

futures-core/src/future/mod.rs → futures-core/src/future.rs

@@ -1,27 +1,9 @@
 //! Futures.
 
 use crate::task::{self, Poll};
-use core::marker::Unpin;
 use core::mem::PinMut;
-pub use core::future::{Future, FutureObj, LocalFutureObj, UnsafeFutureObj};
-
-mod option;
-pub use self::option::FutureOption;
-
-#[cfg(feature = "either")]
-mod either;
-
-/// Will probably merge with futures_util::FutureExt
-pub trait CoreFutureExt: Future {
-    /// A convenience for calling `Future::poll` on `Unpin` future types.
-    fn poll_unpin(&mut self, cx: &mut task::Context) -> Poll<Self::Output>
-        where Self: Unpin + Sized
-    {
-        PinMut::new(self).poll(cx)
-    }
-}
 
-impl<T: ?Sized> CoreFutureExt for T where T: Future {}
+pub use core::future::{Future, FutureObj, LocalFutureObj, UnsafeFutureObj};
 
 /// A convenience for futures that return `Result` values that includes
 /// a variety of adapters tailored to such futures.
@@ -54,24 +36,3 @@ impl<F, T, E> TryFuture for F
         self.poll(cx)
     }
 }
-
-/// A future that is immediately ready with a value
-#[derive(Debug, Clone)]
-#[must_use = "futures do nothing unless polled"]
-pub struct ReadyFuture<T>(Option<T>);
-
-impl<T> Unpin for ReadyFuture<T> {}
-
-impl<T> Future for ReadyFuture<T> {
-    type Output = T;
-
-    #[inline]
-    fn poll(mut self: PinMut<Self>, _cx: &mut task::Context) -> Poll<T> {
-        Poll::Ready(self.0.take().unwrap())
-    }
-}
-
-/// Create a future that is immediately ready with a value.
-pub fn ready<T>(t: T) -> ReadyFuture<T> {
-    ReadyFuture(Some(t))
-}

futures-core/src/lib.rs

@@ -11,19 +11,13 @@
 
 #![cfg_attr(feature = "nightly", feature(cfg_target_has_atomic))]
 
-#[macro_use]
 #[cfg(feature = "std")]
 extern crate std;
+
 #[cfg(feature = "either")]
 extern crate either;
 
-#[doc(hidden)]
-pub mod core_reexport {
-    pub use core::{mem, future, task};
-}
-
 #[doc(hidden)] pub use crate::future::Future;
-#[doc(hidden)] pub use crate::future::CoreFutureExt;
 #[doc(hidden)] pub use crate::future::TryFuture;
 
 #[doc(hidden)] pub use crate::stream::Stream;
@@ -38,9 +32,6 @@ macro_rules! if_std {
     )*)
 }
 
-#[macro_use]
-mod macros;
-
 pub mod future;
 
 pub mod stream;

futures-core/src/stream/mod.rs → futures-core/src/stream.rs

@@ -4,6 +4,9 @@ use crate::task::{self, Poll};
 use core::marker::Unpin;
 use core::mem::PinMut;
 
+#[cfg(feature = "either")]
+use either::Either;
+
 /// A stream of values produced asynchronously.
 ///
 /// If `Future<Output = T>` is an asynchronous version of `T`, then `Stream<Item
@@ -80,6 +83,23 @@ impl<'a, S: ?Sized + Stream> Stream for PinMut<'a, S> {
     }
 }
 
+#[cfg(feature = "either")]
+impl<A, B> Stream for Either<A, B>
+    where A: Stream,
+          B: Stream<Item = A::Item>
+{
+    type Item = A::Item;
+
+    fn poll_next(self: PinMut<Self>, cx: &mut task::Context) -> Poll<Option<A::Item>> {
+        unsafe {
+            match PinMut::get_mut_unchecked(self) {
+                Either::Left(a) => PinMut::new_unchecked(a).poll_next(cx),
+                Either::Right(b) => PinMut::new_unchecked(b).poll_next(cx),
+            }
+        }
+    }
+}
+
 /// A convenience for streams that return `Result` values that includes
 /// a variety of adapters tailored to such futures.
 pub trait TryStream {

futures-core/src/task.rs

@@ -0,0 +1,11 @@
+//! Task notification.
+
+pub use core::task::{
+    Context, Poll, Executor,
+    Waker, LocalWaker, UnsafeWake,
+    SpawnErrorKind, SpawnObjError, SpawnLocalObjError,
+};
+
+if_std! {
+    pub use std::task::{Wake, local_waker, local_waker_from_nonlocal};
+}

futures-executor/src/lib.rs

@@ -13,8 +13,9 @@
 #[macro_use]
 extern crate std;
 
-#[cfg_attr(feature = "std", macro_use)]
-extern crate futures_core;
+#[cfg(feature = "std")]
+#[macro_use]
+extern crate futures_util;
 
 macro_rules! if_std {
     ($($i:item)*) => ($(

futures-executor/src/spawn.rs

@@ -1,8 +1,8 @@
-use futures_core::future::{Future, CoreFutureExt};
-use futures_core::task::{self, Poll, ContextExt};
+use futures_core::future::Future;
+use futures_core::task::{self, Poll};
 use futures_channel::oneshot::{channel, Sender, Receiver};
-use futures_util::FutureExt;
-
+use futures_util::future::FutureExt;
+use futures_util::task::ContextExt;
 use std::thread;
 use std::sync::Arc;
 use std::sync::atomic::Ordering;

futures-executor/src/thread_pool.rs

@@ -1,19 +1,17 @@
-use std::prelude::v1::*;
-
+use crate::enter;
+use crate::unpark_mutex::UnparkMutex;
+use futures_core::future::{Future, FutureObj};
+use futures_core::task::{self, Poll, Wake, Executor, SpawnObjError};
+use futures_util::future::FutureExt;
+use num_cpus;
 use std::io;
+use std::prelude::v1::*;
 use std::sync::{Arc, Mutex};
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::mpsc;
 use std::thread;
 use std::fmt;
 
-use futures_core::future::{Future, FutureObj, CoreFutureExt};
-use futures_core::task::{self, Poll, Wake, Executor, SpawnObjError};
-
-use crate::enter;
-use num_cpus;
-use crate::unpark_mutex::UnparkMutex;
-
 /// A general-purpose thread pool for scheduling asynchronous tasks.
 ///
 /// The thread pool multiplexes any number of tasks onto a fixed number of

futures-util/src/future/mod.rs

@@ -3,9 +3,11 @@
 //! This module contains a number of functions for working with `Future`s,
 //! including the `FutureExt` trait which adds methods to `Future` types.
 
+use core::marker::Unpin;
+use core::mem::PinMut;
 use futures_core::future::Future;
 use futures_core::stream::Stream;
-use futures_core::task::Executor;
+use futures_core::task::{self, Poll, Executor};
 
 // Primitive futures
 mod empty;
@@ -17,9 +19,15 @@ pub use self::lazy::{lazy, Lazy};
 mod maybe_done;
 pub use self::maybe_done::{maybe_done, MaybeDone};
 
+mod option;
+pub use self::option::{OptionFuture};
+
 mod poll_fn;
 pub use self::poll_fn::{poll_fn, PollFn};
 
+mod ready;
+pub use self::ready::{ready, Ready};
+
 // Combinators
 mod flatten;
 pub use self::flatten::Flatten;
@@ -506,14 +514,14 @@ pub trait FutureExt: Future {
     /// ```rust
     /// # extern crate futures;
     /// use futures::prelude::*;
-    /// use futures::future::{self, ReadyFuture};
+    /// use futures::future::{self, Ready};
     /// use futures::executor::block_on;
     ///
     /// # fn main() {
     /// let mut future = future::ready(2);
     /// assert!(block_on(future.catch_unwind()).is_ok());
     ///
-    /// let mut future = future::lazy(|_| -> ReadyFuture<i32> {
+    /// let mut future = future::lazy(|_| -> Ready<i32> {
     ///     panic!();
     ///     future::ready(2)
     /// });
@@ -606,6 +614,13 @@ pub trait FutureExt: Future {
     {
         WithExecutor::new(self, executor)
     }
+
+    /// A convenience for calling `Future::poll` on `Unpin` future types.
+    fn poll_unpin(&mut self, cx: &mut task::Context) -> Poll<Self::Output>
+        where Self: Unpin + Sized
+    {
+        PinMut::new(self).poll(cx)
+    }
 }
 
 // Just a helper function to ensure the futures we're returning all have the