Deprecate boxed methods

These methods have caused far more confusion than they were ever intended to
cause, and they're use rarely enough in practice "to success" that they're
likely to be removed from any 0.2 release. As a result this commit starts out
the removal process by deprecating them and removing usage internally.

Closes #228

Author: alexcrichton

src/future/mod.rs

@@ -97,6 +97,10 @@ if_std! {
     pub use self::join_all::JoinAll as Collect;
 
     /// A type alias for `Box<Future + Send>`
+    #[doc(hidden)]
+    #[deprecated(note = "removed without replacement, recommended to use a \
+                         local extension trait or function if needed, more \
+                         details in #228")]
     pub type BoxFuture<T, E> = ::std::boxed::Box<Future<Item = T, Error = E> + Send>;
 
     impl<F: ?Sized + Future> Future for ::std::boxed::Box<F> {
@@ -313,6 +317,11 @@ pub trait Future {
     /// let a: BoxFuture<i32, i32> = result(Ok(1)).boxed();
     /// ```
     #[cfg(feature = "use_std")]
+    #[doc(hidden)]
+    #[deprecated(note = "removed without replacement, recommended to use a \
+                         local extension trait or function if needed, more \
+                         details in #228")]
+    #[allow(deprecated)]
     fn boxed(self) -> BoxFuture<Self::Item, Self::Error>
         where Self: Sized + Send + 'static
     {

src/lib.rs

@@ -234,6 +234,7 @@ if_std! {
     #[doc(hidden)]
     #[deprecated(since = "0.1.4", note = "import through the future module instead")]
     #[cfg(feature = "with-deprecated")]
+    #[allow(deprecated)]
     pub use future::{BoxFuture, collect, select_all, select_ok};
 
     #[doc(hidden)]

src/stream/mod.rs

@@ -112,6 +112,10 @@ if_std! {
     pub use self::channel::{channel, Sender, Receiver, FutureSender, SendError};
 
     /// A type alias for `Box<Stream + Send>`
+    #[doc(hidden)]
+    #[deprecated(note = "removed without replacement, recommended to use a \
+                         local extension trait or function if needed, more \
+                         details in #228")]
     pub type BoxStream<T, E> = ::std::boxed::Box<Stream<Item = T, Error = E> + Send>;
 
     impl<S: ?Sized + Stream> Stream for ::std::boxed::Box<S> {
@@ -251,6 +255,11 @@ pub trait Stream {
     /// let a: BoxStream<i32, ()> = rx.boxed();
     /// ```
     #[cfg(feature = "use_std")]
+    #[doc(hidden)]
+    #[deprecated(note = "removed without replacement, recommended to use a \
+                         local extension trait or function if needed, more \
+                         details in #228")]
+    #[allow(deprecated)]
     fn boxed(self) -> BoxStream<Self::Item, Self::Error>
         where Self: Sized + Send + 'static,
     {

src/task_impl/std/mod.rs

@@ -10,7 +10,6 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::thread;
 
 use {Future, Stream, Sink, Poll, Async, StartSend, AsyncSink};
-use future::BoxFuture;
 use super::core;
 use super::{BorrowedTask, NotifyHandle, Spawn, spawn, Notify, UnsafeNotify};
 
@@ -276,7 +275,7 @@ impl<F: Future> Spawn<F> {
             // `Spawn<BoxFuture<(), ()>>` so we wouldn't have to box here and
             // it'd be more explicit, but unfortunately that currently has a
             // link error on nightly: rust-lang/rust#36155
-            spawn: spawn(self.into_inner().boxed()),
+            spawn: spawn(Box::new(self.into_inner())),
             inner: Arc::new(RunInner {
                 exec: exec,
                 mutex: UnparkMutex::new()
@@ -404,7 +403,7 @@ pub trait Executor: Send + Sync + 'static {
 /// Units of work submitted to an `Executor`, currently only created
 /// internally.
 pub struct Run {
-    spawn: Spawn<BoxFuture<(), ()>>,
+    spawn: Spawn<Box<Future<Item = (), Error = ()> + Send>>,
     inner: Arc<RunInner>,
 }
 

tests/channel.rs

@@ -27,11 +27,11 @@ fn sequence() {
     fn send(n: u32, sender: mpsc::Sender<u32>)
             -> Box<Future<Item=(), Error=()> + Send> {
         if n == 0 {
-            return result(Ok(())).boxed()
+            return Box::new(result(Ok(())))
         }
-        sender.send(n).map_err(|_| ()).and_then(move |sender| {
+        Box::new(sender.send(n).map_err(|_| ()).and_then(move |sender| {
             send(n - 1, sender)
-        }).boxed()
+        }))
     }
 }
 

tests/futures_ordered.rs

@@ -34,7 +34,10 @@ fn works_2() {
     let (b_tx, b_rx) = oneshot::channel::<u32>();
     let (c_tx, c_rx) = oneshot::channel::<u32>();
 
-    let stream = futures_ordered(vec![a_rx.boxed(), b_rx.join(c_rx).map(|(a, b)| a + b).boxed()]);
+    let stream = futures_ordered(vec![
+        Box::new(a_rx) as Box<Future<Item = _, Error = _>>,
+        Box::new(b_rx.join(c_rx).map(|(a, b)| a + b)),
+    ]);
 
     let mut spawn = futures::executor::spawn(stream);
     a_tx.send(33).unwrap();
@@ -52,8 +55,8 @@ fn queue_never_unblocked() {
     let (c_tx, c_rx) = oneshot::channel::<Box<Any+Send>>();
 
     let stream = futures_ordered(vec![
-        a_rx.boxed(),
-        b_rx.select(c_rx).then(|res| Ok(Box::new(res) as Box<Any+Send>)).boxed(),
+        Box::new(a_rx) as Box<Future<Item = _, Error = _>>,
+        Box::new(b_rx.select(c_rx).then(|res| Ok(Box::new(res) as Box<Any+Send>))),
     ]);
 
     let mut spawn = futures::executor::spawn(stream);

tests/futures_unordered.rs

@@ -33,7 +33,10 @@ fn works_2() {
     let (b_tx, b_rx) = oneshot::channel::<u32>();
     let (c_tx, c_rx) = oneshot::channel::<u32>();
 
-    let stream = futures_unordered(vec![a_rx.boxed(), b_rx.join(c_rx).map(|(a, b)| a + b).boxed()]);
+    let stream = futures_unordered(vec![
+        Box::new(a_rx) as Box<Future<Item = _, Error = _>>,
+        Box::new(b_rx.join(c_rx).map(|(a, b)| a + b)),
+    ]);
 
     let mut spawn = futures::executor::spawn(stream);
     a_tx.send(33).unwrap();
@@ -50,8 +53,8 @@ fn finished_future_ok() {
     let (c_tx, c_rx) = oneshot::channel::<Box<Any+Send>>();
 
     let stream = futures_unordered(vec![
-        a_rx.boxed(),
-        b_rx.select(c_rx).then(|res| Ok(Box::new(res) as Box<Any+Send>)).boxed(),
+        Box::new(a_rx) as Box<Future<Item = _, Error = _>>,
+        Box::new(b_rx.select(c_rx).then(|res| Ok(Box::new(res) as Box<Any+Send>))),
     ]);
 
     let mut spawn = futures::executor::spawn(stream);

tests/mpsc.rs

@@ -298,7 +298,7 @@ fn stress_drop_sender() {
           .and_then(|tx| tx.send(Ok(2)))
           .and_then(|tx| tx.send(Ok(3)))
           .forget();
-        rx.then(|r| r.unwrap()).boxed()
+        Box::new(rx.then(|r| r.unwrap()))
     }
 
     for _ in 0..10000 {

tests/recurse.rs

@@ -8,9 +8,9 @@ use futures::future::{ok, Future};
 fn lots() {
     fn doit(n: usize) -> Box<Future<Item=(), Error=()> + Send> {
         if n == 0 {
-            ok(()).boxed()
+            Box::new(ok(()))
         } else {
-            ok(n - 1).and_then(doit).boxed()
+            Box::new(ok(n - 1).and_then(doit))
         }
     }
 

tests/select_all.rs

@@ -5,9 +5,9 @@ use futures::future::*;
 #[test]
 fn smoke() {
     let v = vec![
-        ok(1).boxed(),
-        err(2).boxed(),
-        ok(3).boxed(),
+        ok(1),
+        err(2),
+        ok(3),
     ];
 
     let (i, idx, v) = select_all(v).wait().ok().unwrap();

tests/select_ok.rs

@@ -5,10 +5,10 @@ use futures::future::*;
 #[test]
 fn ignore_err() {
     let v = vec![
-        err(1).boxed(),
-        err(2).boxed(),
-        ok(3).boxed(),
-        ok(4).boxed(),
+        err(1),
+        err(2),
+        ok(3),
+        ok(4),
     ];
 
     let (i, v) = select_ok(v).wait().ok().unwrap();
@@ -25,9 +25,9 @@ fn ignore_err() {
 #[test]
 fn last_err() {
     let v = vec![
-        ok(1).boxed(),
-        err(2).boxed(),
-        err(3).boxed(),
+        ok(1),
+        err(2),
+        err(3),
     ];
 
     let (i, v) = select_ok(v).wait().ok().unwrap();

tests/sink.rs

@@ -133,9 +133,9 @@ fn mpsc_blocking_start_send() {
 // until a oneshot is completed
 fn with_flush() {
     let (tx, rx) = oneshot::channel();
-    let mut block = rx.boxed();
+    let mut block = Box::new(rx) as Box<Future<Item = _, Error = _>>;
     let mut sink = Vec::new().with(|elem| {
-        mem::replace(&mut block, ok(()).boxed())
+        mem::replace(&mut block, Box::new(ok(())))
             .map(move |_| elem + 1).map_err(|_| -> () { panic!() })
     });
 

tests/stream.rs

@@ -4,30 +4,30 @@ extern crate futures;
 use futures::{Async, Future, Poll, Sink, Stream};
 use futures::executor;
 use futures::future::{err, ok};
-use futures::stream::{empty, iter, poll_fn, BoxStream, Peekable};
+use futures::stream::{empty, iter, poll_fn, Peekable};
 use futures::sync::oneshot;
 use futures::sync::mpsc;
 
 mod support;
 use support::*;
 
 
-fn list() -> BoxStream<i32, u32> {
+fn list() -> Box<Stream<Item=i32, Error=u32> + Send> {
     let (tx, rx) = mpsc::channel(1);
     tx.send(Ok(1))
       .and_then(|tx| tx.send(Ok(2)))
       .and_then(|tx| tx.send(Ok(3)))
       .forget();
-    rx.then(|r| r.unwrap()).boxed()
+    Box::new(rx.then(|r| r.unwrap()))
 }
 
-fn err_list() -> BoxStream<i32, u32> {
+fn err_list() -> Box<Stream<Item=i32, Error=u32> + Send> {
     let (tx, rx) = mpsc::channel(1);
     tx.send(Ok(1))
       .and_then(|tx| tx.send(Ok(2)))
       .and_then(|tx| tx.send(Err(3)))
       .forget();
-    rx.then(|r| r.unwrap()).boxed()
+    Box::new(rx.then(|r| r.unwrap()))
 }
 
 #[test]
@@ -173,8 +173,8 @@ fn buffered() {
     let (a, b) = oneshot::channel::<u32>();
     let (c, d) = oneshot::channel::<u32>();
 
-    tx.send(b.map_err(|_| ()).boxed())
-      .and_then(|tx| tx.send(d.map_err(|_| ()).boxed()))
+    tx.send(Box::new(b.map_err(|_| ())) as Box<Future<Item = _, Error = _> + Send>)
+      .and_then(|tx| tx.send(Box::new(d.map_err(|_| ()))))
       .forget();
 
     let mut rx = rx.buffered(2);
@@ -191,8 +191,8 @@ fn buffered() {
     let (a, b) = oneshot::channel::<u32>();
     let (c, d) = oneshot::channel::<u32>();
 
-    tx.send(b.map_err(|_| ()).boxed())
-      .and_then(|tx| tx.send(d.map_err(|_| ()).boxed()))
+    tx.send(Box::new(b.map_err(|_| ())) as Box<Future<Item = _, Error = _> + Send>)
+      .and_then(|tx| tx.send(Box::new(d.map_err(|_| ()))))
       .forget();
 
     let mut rx = rx.buffered(1);
@@ -212,8 +212,8 @@ fn unordered() {
     let (a, b) = oneshot::channel::<u32>();
     let (c, d) = oneshot::channel::<u32>();
 
-    tx.send(b.map_err(|_| ()).boxed())
-      .and_then(|tx| tx.send(d.map_err(|_| ()).boxed()))
+    tx.send(Box::new(b.map_err(|_| ())) as Box<Future<Item = _, Error = _> + Send>)
+      .and_then(|tx| tx.send(Box::new(d.map_err(|_| ()))))
       .forget();
 
     let mut rx = rx.buffer_unordered(2);
@@ -229,8 +229,8 @@ fn unordered() {
     let (a, b) = oneshot::channel::<u32>();
     let (c, d) = oneshot::channel::<u32>();
 
-    tx.send(b.map_err(|_| ()).boxed())
-      .and_then(|tx| tx.send(d.map_err(|_| ()).boxed()))
+    tx.send(Box::new(b.map_err(|_| ())) as Box<Future<Item = _, Error = _> + Send>)
+      .and_then(|tx| tx.send(Box::new(d.map_err(|_| ()))))
       .forget();
 
     // We don't even get to see `c` until `a` completes.
@@ -261,7 +261,7 @@ fn zip() {
 #[test]
 fn peek() {
     struct Peek {
-        inner: Peekable<BoxStream<i32, u32>>
+        inner: Peekable<Box<Stream<Item = i32, Error =u32> + Send>>
     }
 
     impl Future for Peek {