Add an on-by-default use_std feature to futures

This commit adds a new Cargo feature to the `futures` crate, `use_std`, which is
enabled by default. The `futures` crate is now tagged as `#![no_std]` with extra
support like tasks, oneshot, and channels coming in through the `use_std`
feature. Most crates will likely depend on the `use_std` version, but that
shouldn't preclude those that don't want to!

Closes rust-lang#60

.travis.yml

@@ -20,6 +20,8 @@ sudo: false
 before_script:
   - pip install git+https://github.com/euclio/travis-cargo@kcov --user && export PATH=$HOME/.local/bin:$PATH
 script:
+  - cargo build
+  - cargo build --no-default-features
   - cargo test
   - cargo test --manifest-path futures-io/Cargo.toml
   - cargo test --manifest-path futures-iobuf/Cargo.toml

Cargo.toml

@@ -30,5 +30,9 @@ members = [
 ]
 
 [dependencies]
-log = "0.3"
-scoped-tls = "0.1"
+log = { version = "0.3", default-features = true }
+scoped-tls = { version = "0.1", optional = true }
+
+[features]
+use_std = ["scoped-tls"]
+default = ["use_std"]

appveyor.yml

@@ -11,6 +11,8 @@ install:
 build: false
 
 test_script:
+  - cargo build
+  - cargo build --no-default-features
   - cargo test
   - cargo test --manifest-path futures-io/Cargo.toml
   - cargo test --manifest-path futures-iobuf/Cargo.toml

src/chain.rs

@@ -1,4 +1,4 @@
-use std::mem;
+use core::mem;
 
 use {Future, Poll};
 

src/collect.rs

@@ -1,3 +1,5 @@
+use std::prelude::v1::*;
+
 use std::mem;
 
 use {Future, IntoFuture, Poll};

src/empty.rs

@@ -1,4 +1,4 @@
-use std::marker;
+use core::marker;
 
 use {Future, Poll};
 

src/executor.rs

@@ -4,6 +4,7 @@
 //! is not currently used much by futures beyond `DEFAULT`.
 
 use std::cell::{Cell, RefCell};
+use std::prelude::v1::*;
 use std::sync::Arc;
 
 /// Encapsulation of a value which has the ability to execute arbitrary code.

src/failed.rs

@@ -1,4 +1,4 @@
-use std::marker;
+use core::marker;
 
 use {Future, Poll};
 

src/finished.rs

@@ -1,4 +1,4 @@
-use std::marker;
+use core::marker;
 
 use {Future, Poll};
 

src/forget.rs

@@ -1,3 +1,5 @@
+use std::prelude::v1::*;
+
 use {Future, Poll};
 use task::Task;
 

src/join.rs

@@ -1,6 +1,6 @@
 #![allow(non_snake_case)]
 
-use std::mem;
+use core::mem;
 
 use {Future, Poll, IntoFuture};
 

src/lazy.rs

@@ -1,4 +1,4 @@
-use std::mem;
+use core::mem;
 
 use {Future, IntoFuture, Poll};
 

src/lib.rs

@@ -149,42 +149,41 @@
 //!
 //! [README]: https://github.com/alexcrichton/futures-rs#futures-rs
 
+#![no_std]
 #![deny(missing_docs)]
 
-use std::thread;
-
 #[macro_use]
-extern crate log;
+#[cfg(feature = "use_std")]
+extern crate scoped_tls;
+#[macro_use]
+#[cfg(feature = "use_std")]
+extern crate std;
 
 #[macro_use]
-extern crate scoped_tls;
+extern crate log;
 
-// internal utilities
-mod lock;
-mod slot;
+macro_rules! if_std {
+    ($($i:item)*) => ($(
+        #[cfg(feature = "use_std")]
+        $i
+    )*)
+}
 
 #[macro_use]
 mod poll;
 pub use poll::Poll;
 
-pub mod task;
-pub mod executor;
-
 // Primitive futures
-mod collect;
 mod done;
 mod empty;
 mod failed;
 mod finished;
 mod lazy;
-mod oneshot;
-pub use collect::{collect, Collect};
 pub use done::{done, Done};
 pub use empty::{empty, Empty};
 pub use failed::{failed, Failed};
 pub use finished::{finished, Finished};
 pub use lazy::{lazy, Lazy};
-pub use oneshot::{oneshot, Oneshot, Complete, Canceled};
 
 // combinators
 mod and_then;
@@ -195,7 +194,6 @@ mod map;
 mod map_err;
 mod or_else;
 mod select;
-mod select_all;
 mod then;
 pub use and_then::AndThen;
 pub use flatten::Flatten;
@@ -205,16 +203,49 @@ pub use map::Map;
 pub use map_err::MapErr;
 pub use or_else::OrElse;
 pub use select::{Select, SelectNext};
-pub use select_all::{SelectAll, SelectAllNext, select_all};
 pub use then::Then;
 
+if_std! {
+    mod lock;
+    mod slot;
+    pub mod task;
+    pub mod executor;
+
+    mod collect;
+    mod oneshot;
+    mod select_all;
+    pub use collect::{collect, Collect};
+    pub use oneshot::{oneshot, Oneshot, Complete, Canceled};
+    pub use select_all::{SelectAll, SelectAllNext, select_all};
+
+    mod forget;
+
+    struct ThreadNotify(std::thread::Thread);
+
+    impl task::Notify for ThreadNotify {
+        fn notify(&self) {
+            self.0.unpark();
+        }
+    }
+
+    /// A type alias for `Box<Future + Send>`
+    pub type BoxFuture<T, E> = std::boxed::Box<Future<Item = T, Error = E> + Send>;
+
+    impl<F: ?Sized + Future> Future for std::boxed::Box<F> {
+        type Item = F::Item;
+        type Error = F::Error;
+
+        fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+            (**self).poll()
+        }
+    }
+}
+
 // streams
 pub mod stream;
 
 // impl details
 mod chain;
-mod impls;
-mod forget;
 
 /// Trait for types which are a placeholder of a value that will become
 /// available at possible some later point in time.
@@ -351,9 +382,12 @@ pub trait Future {
     ///
     /// This function does not attempt to catch panics. If the `poll` function
     /// panics, panics will be propagated to the caller.
+    #[cfg(feature = "use_std")]
     fn await(mut self) -> Result<Self::Item, Self::Error>
         where Self: Sized
     {
+        use std::thread;
+
         let notify = ThreadNotify(thread::current());
         let mut task = task::Task::new_notify(notify);
         loop {
@@ -380,10 +414,11 @@ pub trait Future {
     ///
     /// let a: BoxFuture<i32, i32> = done(Ok(1)).boxed();
     /// ```
+    #[cfg(feature = "use_std")]
     fn boxed(self) -> BoxFuture<Self::Item, Self::Error>
         where Self: Sized + Send + 'static
     {
-        Box::new(self)
+        ::std::boxed::Box::new(self)
     }
 
     /// Map this future's result to a different type, returning a new future of
@@ -782,13 +817,20 @@ pub trait Future {
     /// `futures-mio` crate provides a `Loop::run` method which pins the future
     /// to the stack frame of that functionc all, allowing it to have a
     /// non-`'static` lifetime.
+    #[cfg(feature = "use_std")]
     fn forget(self) where Self: Sized + Send + 'static {
         forget::forget(self);
     }
 }
 
-/// A type alias for `Box<Future + Send>`
-pub type BoxFuture<T, E> = Box<Future<Item = T, Error = E> + Send>;
+impl<'a, F: ?Sized + Future> Future for &'a mut F {
+    type Item = F::Item;
+    type Error = F::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        (**self).poll()
+    }
+}
 
 // Just a helper function to ensure the futures we're returning all have the
 // right implementations.
@@ -834,11 +876,3 @@ impl<T, E> IntoFuture for Result<T, E> {
         done(self)
     }
 }
-
-struct ThreadNotify(thread::Thread);
-
-impl task::Notify for ThreadNotify {
-    fn notify(&self) {
-        self.0.unpark();
-    }
-}

src/lock.rs

@@ -4,10 +4,10 @@
 //! thing that ever blocks, so this is assisted with a fast user-space
 //! implementation of a lock that can only have a `try_lock` operation.
 
-use std::cell::UnsafeCell;
-use std::ops::{Deref, DerefMut};
-use std::sync::atomic::Ordering::{Acquire, Release};
-use std::sync::atomic::AtomicBool;
+use core::cell::UnsafeCell;
+use core::ops::{Deref, DerefMut};
+use core::sync::atomic::Ordering::{Acquire, Release};
+use core::sync::atomic::AtomicBool;
 
 /// A "mutex" around a value, similar to `std::sync::Mutex<T>`.
 ///

src/select_all.rs

@@ -1,4 +1,5 @@
 use std::mem;
+use std::prelude::v1::*;
 
 use {Future, IntoFuture, Poll};
 

src/slot.rs

@@ -7,6 +7,7 @@
 
 #![allow(dead_code)] // imported in a few places
 
+use std::prelude::v1::*;
 use std::sync::atomic::{AtomicUsize, Ordering};
 
 use lock::Lock;

src/stream/buffered.rs

@@ -1,3 +1,5 @@
+use std::prelude::v1::*;
+
 use std::mem;
 
 use {IntoFuture, Poll, Future};

src/stream/collect.rs

@@ -1,3 +1,5 @@
+use std::prelude::v1::*;
+
 use std::mem;
 
 use {Future, Poll};

src/stream/fold.rs

@@ -1,4 +1,4 @@
-use std::mem;
+use core::mem;
 
 use {Future, Poll, IntoFuture};
 use stream::Stream;