Core cleanup

Author: MajorBreakfast

futures-core/src/future/mod.rs renamed to 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/future/either.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/future/option.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/lib.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-core/src/macros/poll.rs

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

futures-core/src/stream/mod.rs renamed to futures-core/src/stream.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;