Remove StreamObj, caution against using FutureObj

Author: Nemo157

futures-core/src/future/future_obj.rs

@@ -9,9 +9,9 @@ use core::{
 /// A custom trait object for polling futures, roughly akin to
 /// `Box<dyn Future<Output = T> + 'a>`.
 ///
-/// This custom trait object was introduced for two reasons:
-/// - Currently it is not possible to take `dyn Trait` by value and
-///   `Box<dyn Trait>` is not available in no_std contexts.
+/// This custom trait object was introduced as currently it is not possible to
+/// take `dyn Trait` by value and `Box<dyn Trait>` is not available in no_std
+/// contexts.
 pub struct LocalFutureObj<'a, T> {
     ptr: *mut (),
     poll_fn: unsafe fn(*mut (), &mut Context<'_>) -> Poll<T>,
@@ -79,14 +79,13 @@ impl<'a, T> Drop for LocalFutureObj<'a, T> {
 /// A custom trait object for polling futures, roughly akin to
 /// `Box<dyn Future<Output = T> + Send + 'a>`.
 ///
-/// This custom trait object was introduced for two reasons:
-/// - Currently it is not possible to take `dyn Trait` by value and
-///   `Box<dyn Trait>` is not available in no_std contexts.
-/// - The `Future` trait is currently not object safe: The `Future::poll`
-///   method makes uses the arbitrary self types feature and traits in which
-///   this feature is used are currently not object safe due to current compiler
-///   limitations. (See tracking issue for arbitrary self types for more
-///   information #44874)
+/// This custom trait object was introduced as currently it is not possible to
+/// take `dyn Trait` by value and `Box<dyn Trait>` is not available in no_std
+/// contexts.
+///
+/// You should generally not need to use this type outside of `no_std` or when
+/// implementing `Spawn`, consider using [`BoxFuture`](crate::future::BoxFuture)
+/// instead.
 pub struct FutureObj<'a, T>(LocalFutureObj<'a, T>);
 
 impl<'a, T> Unpin for FutureObj<'a, T> {}

futures-core/src/future/mod.rs

@@ -8,6 +8,11 @@ pub use core::future::Future;
 mod future_obj;
 pub use self::future_obj::{FutureObj, LocalFutureObj, UnsafeFutureObj};
 
+#[cfg(feature = "alloc")]
+/// An owned dynamically typed [`Future`] for use in cases where you can't
+/// statically type your result or need to add some indirection.
+pub type BoxFuture<'a, T> = Pin<alloc::boxed::Box<dyn Future<Output = T> + Send + 'a>>;
+
 /// A `Future` or `TryFuture` which tracks whether or not the underlying future
 /// should no longer be polled.
 ///

futures-core/src/stream/mod.rs

@@ -7,8 +7,10 @@ use core::task::{Context, Poll};
 #[cfg(feature = "either")]
 use either::Either;
 
-mod stream_obj;
-pub use self::stream_obj::{StreamObj,LocalStreamObj,UnsafeStreamObj};
+#[cfg(feature = "alloc")]
+/// An owned dynamically typed [`Stream`] for use in cases where you can't
+/// statically type your result or need to add some indirection.
+pub type BoxStream<'a, T> = Pin<alloc::boxed::Box<dyn Stream<Item = T> + Send + 'a>>;
 
 /// A stream of values produced asynchronously.
 ///

futures-core/src/stream/stream_obj.rs

@@ -185,6 +185,9 @@ pub mod future {
         FutureObj, LocalFutureObj, UnsafeFutureObj,
     };
 
+    #[cfg(feature = "alloc")]
+    pub use futures_core::future::BoxFuture;
+
     pub use futures_util::future::{
         empty, Empty,
         lazy, Lazy,
@@ -326,9 +329,11 @@ pub mod stream {
 
     pub use futures_core::stream::{
         Stream, TryStream, FusedStream,
-        StreamObj, LocalStreamObj, UnsafeStreamObj,
     };
 
+    #[cfg(feature = "alloc")]
+    pub use futures_core::stream::BoxStream;
+
     pub use futures_util::stream::{
         iter, Iter,
         repeat, Repeat,

futures/src/lib.rs

@@ -2,9 +2,8 @@
 
 use futures::channel::oneshot;
 use futures::executor::{block_on, block_on_stream};
-use futures::future::{self, join, FutureExt, FutureObj};
-use futures::stream::{StreamExt, FuturesOrdered};
-use futures::task::Context;
+use futures::future::{self, FutureExt, BoxFuture};
+use futures::stream::{StreamExt, futures_ordered, FuturesOrdered};
 use futures_test::task::noop_waker_ref;
 
 #[test]
@@ -34,10 +33,10 @@ fn works_2() {
     let (b_tx, b_rx) = oneshot::channel::<i32>();
     let (c_tx, c_rx) = oneshot::channel::<i32>();
 
-    let mut stream = vec![
-        FutureObj::new(Box::new(a_rx)),
-        FutureObj::new(Box::new(join(b_rx, c_rx).map(|(a, b)| Ok(a? + b?)))),
-    ].into_iter().collect::<FuturesOrdered<_>>();
+    let mut stream = futures_ordered(vec![
+        a_rx.boxed(),
+        join(b_rx, c_rx).map(|(a, b)| Ok(a? + b?)).boxed(),
+    ]);
 
     let mut cx = Context::from_waker(noop_waker_ref());
     a_tx.send(33).unwrap();