refactor: TryFutures are Futures now, into_future is no longer need

futures-core/src/future.rs

@@ -55,7 +55,10 @@ mod private_try_future {
 
 /// A convenience for futures that return `Result` values that includes
 /// a variety of adapters tailored to such futures.
-pub trait TryFuture: Future + private_try_future::Sealed {
+pub trait TryFuture:
+    Future<Output = Result<<Self as TryFuture>::Ok, <Self as TryFuture>::Error>>
+    + private_try_future::Sealed
+{
     /// The type of successful values yielded by this future
     type Ok;
 

futures-core/src/stream.rs

@@ -164,7 +164,10 @@ mod private_try_stream {
 
 /// A convenience for streams that return `Result` values that includes
 /// a variety of adapters tailored to such futures.
-pub trait TryStream: Stream + private_try_stream::Sealed {
+pub trait TryStream:
+    Stream<Item = Result<<Self as TryStream>::Ok, <Self as TryStream>::Error>>
+    + private_try_stream::Sealed
+{
     /// The type of successful values yielded by this future
     type Ok;
 

futures-util/src/future/mod.rs

@@ -40,8 +40,8 @@ pub use self::future::{Shared, WeakShared};
 
 mod try_future;
 pub use self::try_future::{
-    AndThen, ErrInto, InspectErr, InspectOk, IntoFuture, MapErr, MapOk, MapOkOrElse, OkInto,
-    OrElse, TryFlatten, TryFlattenStream, TryFutureExt, UnwrapOrElse,
+    AndThen, ErrInto, InspectErr, InspectOk, MapErr, MapOk, MapOkOrElse, OkInto, OrElse,
+    TryFlatten, TryFlattenStream, TryFutureExt, UnwrapOrElse,
 };
 
 #[cfg(feature = "sink")]

futures-util/src/future/try_future/mod.rs

@@ -23,7 +23,6 @@ use crate::future::{assert_future, Inspect, Map};
 use crate::stream::assert_stream;
 
 // Combinators
-mod into_future;
 mod try_flatten;
 mod try_flatten_err;
 
@@ -89,45 +88,43 @@ delegate_all!(
 delegate_all!(
     /// Future for the [`inspect_ok`](super::TryFutureExt::inspect_ok) method.
     InspectOk<Fut, F>(
-        Inspect<IntoFuture<Fut>, InspectOkFn<F>>
-    ): Debug + Future + FusedFuture + New[|x: Fut, f: F| Inspect::new(IntoFuture::new(x), inspect_ok_fn(f))]
+        Inspect<Fut, InspectOkFn<F>>
+    ): Debug + Future + FusedFuture + New[|x: Fut, f: F| Inspect::new(x, inspect_ok_fn(f))]
 );
 
 delegate_all!(
     /// Future for the [`inspect_err`](super::TryFutureExt::inspect_err) method.
     InspectErr<Fut, F>(
-        Inspect<IntoFuture<Fut>, InspectErrFn<F>>
-    ): Debug + Future + FusedFuture + New[|x: Fut, f: F| Inspect::new(IntoFuture::new(x), inspect_err_fn(f))]
+        Inspect<Fut, InspectErrFn<F>>
+    ): Debug + Future + FusedFuture + New[|x: Fut, f: F| Inspect::new(x, inspect_err_fn(f))]
 );
 
-pub use self::into_future::IntoFuture;
-
 delegate_all!(
     /// Future for the [`map_ok`](TryFutureExt::map_ok) method.
     MapOk<Fut, F>(
-        Map<IntoFuture<Fut>, MapOkFn<F>>
-    ): Debug + Future + FusedFuture + New[|x: Fut, f: F| Map::new(IntoFuture::new(x), map_ok_fn(f))]
+        Map<Fut, MapOkFn<F>>
+    ): Debug + Future + FusedFuture + New[|x: Fut, f: F| Map::new(x, map_ok_fn(f))]
 );
 
 delegate_all!(
     /// Future for the [`map_err`](TryFutureExt::map_err) method.
     MapErr<Fut, F>(
-        Map<IntoFuture<Fut>, MapErrFn<F>>
-    ): Debug + Future + FusedFuture + New[|x: Fut, f: F| Map::new(IntoFuture::new(x), map_err_fn(f))]
+        Map<Fut, MapErrFn<F>>
+    ): Debug + Future + FusedFuture + New[|x: Fut, f: F| Map::new(x, map_err_fn(f))]
 );
 
 delegate_all!(
     /// Future for the [`map_ok_or_else`](TryFutureExt::map_ok_or_else) method.
     MapOkOrElse<Fut, F, G>(
-        Map<IntoFuture<Fut>, MapOkOrElseFn<F, G>>
-    ): Debug + Future + FusedFuture + New[|x: Fut, f: F, g: G| Map::new(IntoFuture::new(x), map_ok_or_else_fn(f, g))]
+        Map<Fut, MapOkOrElseFn<F, G>>
+    ): Debug + Future + FusedFuture + New[|x: Fut, f: F, g: G| Map::new(x, map_ok_or_else_fn(f, g))]
 );
 
 delegate_all!(
     /// Future for the [`unwrap_or_else`](TryFutureExt::unwrap_or_else) method.
     UnwrapOrElse<Fut, F>(
-        Map<IntoFuture<Fut>, UnwrapOrElseFn<F>>
-    ): Debug + Future + FusedFuture + New[|x: Fut, f: F| Map::new(IntoFuture::new(x), unwrap_or_else_fn(f))]
+        Map<Fut, UnwrapOrElseFn<F>>
+    ): Debug + Future + FusedFuture + New[|x: Fut, f: F| Map::new(x, unwrap_or_else_fn(f))]
 );
 
 impl<Fut: ?Sized + TryFuture> TryFutureExt for Fut {}
@@ -585,34 +582,6 @@ pub trait TryFutureExt: TryFuture {
         Compat::new(self)
     }
 
-    /// Wraps a [`TryFuture`] into a type that implements
-    /// [`Future`](std::future::Future).
-    ///
-    /// [`TryFuture`]s currently do not implement the
-    /// [`Future`](std::future::Future) trait due to limitations of the
-    /// compiler.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use futures::future::{Future, TryFuture, TryFutureExt};
-    ///
-    /// # type T = i32;
-    /// # type E = ();
-    /// fn make_try_future() -> impl TryFuture<Ok = T, Error = E> { // ... }
-    /// # async { Ok::<i32, ()>(1) }
-    /// # }
-    /// fn take_future(future: impl Future<Output = Result<T, E>>) { /* ... */ }
-    ///
-    /// take_future(make_try_future().into_future());
-    /// ```
-    fn into_future(self) -> IntoFuture<Self>
-    where
-        Self: Sized,
-    {
-        assert_future::<Result<Self::Ok, Self::Error>, _>(IntoFuture::new(self))
-    }
-
     /// A convenience method for calling [`TryFuture::try_poll`] on [`Unpin`]
     /// future types.
     fn try_poll_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Result<Self::Ok, Self::Error>>

futures-util/src/future/try_join_all.rs

@@ -10,11 +10,10 @@ use core::mem;
 use core::pin::Pin;
 use core::task::{Context, Poll};
 
-use super::{assert_future, join_all, IntoFuture, TryFuture, TryMaybeDone};
+use super::{assert_future, join_all, TryFuture, TryMaybeDone};
 
 #[cfg_attr(target_os = "none", cfg(target_has_atomic = "ptr"))]
 use crate::stream::{FuturesOrdered, TryCollect, TryStreamExt};
-use crate::TryFutureExt;
 
 enum FinalState<E = ()> {
     Pending,
@@ -36,11 +35,11 @@ where
     F: TryFuture,
 {
     Small {
-        elems: Pin<Box<[TryMaybeDone<IntoFuture<F>>]>>,
+        elems: Pin<Box<[TryMaybeDone<F>]>>,
     },
     #[cfg_attr(target_os = "none", cfg(target_has_atomic = "ptr"))]
     Big {
-        fut: TryCollect<FuturesOrdered<IntoFuture<F>>, Vec<F::Ok>>,
+        fut: TryCollect<FuturesOrdered<F>, Vec<F::Ok>>,
     },
 }
 
@@ -119,7 +118,7 @@ where
     I: IntoIterator,
     I::Item: TryFuture,
 {
-    let iter = iter.into_iter().map(TryFutureExt::into_future);
+    let iter = iter.into_iter();
 
     #[cfg(target_os = "none")]
     #[cfg_attr(target_os = "none", cfg(not(target_has_atomic = "ptr")))]

futures-util/src/stream/mod.rs

@@ -52,8 +52,8 @@ pub use self::stream::{ReuniteError, SplitSink, SplitStream};
 
 mod try_stream;
 pub use self::try_stream::{
-    try_unfold, AndThen, ErrInto, InspectErr, InspectOk, IntoStream, MapErr, MapOk, OrElse, TryAll,
-    TryAny, TryCollect, TryConcat, TryFilter, TryFilterMap, TryFlatten, TryNext, TrySkipWhile,
+    try_unfold, AndThen, ErrInto, InspectErr, InspectOk, MapErr, MapOk, OrElse, TryAll, TryAny,
+    TryCollect, TryConcat, TryFilter, TryFilterMap, TryFlatten, TryNext, TrySkipWhile,
     TryStreamExt, TryTakeWhile, TryUnfold,
 };
 

futures-util/src/stream/try_stream/mod.rs

@@ -36,32 +36,29 @@ delegate_all!(
 delegate_all!(
     /// Stream for the [`inspect_ok`](super::TryStreamExt::inspect_ok) method.
     InspectOk<St, F>(
-        Inspect<IntoStream<St>, InspectOkFn<F>>
-    ): Debug + Sink + Stream + FusedStream + AccessInner[St, (. .)] + New[|x: St, f: F| Inspect::new(IntoStream::new(x), inspect_ok_fn(f))]
+        Inspect<St, InspectOkFn<F>>
+    ): Debug + Sink + Stream + FusedStream + AccessInner[St, (.)] + New[|x: St, f: F| Inspect::new(x, inspect_ok_fn(f))]
 );
 
 delegate_all!(
     /// Stream for the [`inspect_err`](super::TryStreamExt::inspect_err) method.
     InspectErr<St, F>(
-        Inspect<IntoStream<St>, InspectErrFn<F>>
-    ): Debug + Sink + Stream + FusedStream + AccessInner[St, (. .)] + New[|x: St, f: F| Inspect::new(IntoStream::new(x), inspect_err_fn(f))]
+        Inspect<St, InspectErrFn<F>>
+    ): Debug + Sink + Stream + FusedStream + AccessInner[St, (.)] + New[|x: St, f: F| Inspect::new(x, inspect_err_fn(f))]
 );
 
-mod into_stream;
-pub use self::into_stream::IntoStream;
-
 delegate_all!(
     /// Stream for the [`map_ok`](super::TryStreamExt::map_ok) method.
     MapOk<St, F>(
-        Map<IntoStream<St>, MapOkFn<F>>
-    ): Debug + Sink + Stream + FusedStream + AccessInner[St, (. .)] + New[|x: St, f: F| Map::new(IntoStream::new(x), map_ok_fn(f))]
+        Map<St, MapOkFn<F>>
+    ): Debug + Sink + Stream + FusedStream + AccessInner[St, (.)] + New[|x: St, f: F| Map::new(x, map_ok_fn(f))]
 );
 
 delegate_all!(
     /// Stream for the [`map_err`](super::TryStreamExt::map_err) method.
     MapErr<St, F>(
-        Map<IntoStream<St>, MapErrFn<F>>
-    ): Debug + Sink + Stream + FusedStream + AccessInner[St, (. .)] + New[|x: St, f: F| Map::new(IntoStream::new(x), map_err_fn(f))]
+        Map<St, MapErrFn<F>>
+    ): Debug + Sink + Stream + FusedStream + AccessInner[St, (.)] + New[|x: St, f: F| Map::new(x, map_err_fn(f))]
 );
 
 mod or_else;
@@ -352,34 +349,6 @@ pub trait TryStreamExt: TryStream {
         assert_stream::<Result<Self::Ok, Self::Error>, _>(InspectErr::new(self, f))
     }
 
-    /// Wraps a [`TryStream`] into a type that implements
-    /// [`Stream`](futures_core::stream::Stream)
-    ///
-    /// [`TryStream`]s currently do not implement the
-    /// [`Stream`](futures_core::stream::Stream) trait because of limitations
-    /// of the compiler.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use futures::stream::{Stream, TryStream, TryStreamExt};
-    ///
-    /// # type T = i32;
-    /// # type E = ();
-    /// fn make_try_stream() -> impl TryStream<Ok = T, Error = E> { // ... }
-    /// # futures::stream::empty()
-    /// # }
-    /// fn take_stream(stream: impl Stream<Item = Result<T, E>>) { /* ... */ }
-    ///
-    /// take_stream(make_try_stream().into_stream());
-    /// ```
-    fn into_stream(self) -> IntoStream<Self>
-    where
-        Self: Sized,
-    {
-        assert_stream::<Result<Self::Ok, Self::Error>, _>(IntoStream::new(self))
-    }
-
     /// Creates a future that attempts to resolve the next item in the stream.
     /// If an error is encountered before the next item, the error is returned
     /// instead.

futures-util/src/stream/try_stream/try_buffer_unordered.rs

@@ -1,5 +1,4 @@
-use crate::future::{IntoFuture, TryFutureExt};
-use crate::stream::{Fuse, FuturesUnordered, IntoStream, StreamExt};
+use crate::stream::{Fuse, FuturesUnordered, StreamExt};
 use core::num::NonZeroUsize;
 use core::pin::Pin;
 use futures_core::future::TryFuture;
@@ -18,8 +17,8 @@ pin_project! {
         where St: TryStream
     {
         #[pin]
-        stream: Fuse<IntoStream<St>>,
-        in_progress_queue: FuturesUnordered<IntoFuture<St::Ok>>,
+        stream: Fuse<St>,
+        in_progress_queue: FuturesUnordered<St::Ok>,
         max: Option<NonZeroUsize>,
     }
 }
@@ -31,13 +30,13 @@ where
 {
     pub(super) fn new(stream: St, n: Option<usize>) -> Self {
         Self {
-            stream: IntoStream::new(stream).fuse(),
+            stream: stream.fuse(),
             in_progress_queue: FuturesUnordered::new(),
             max: n.and_then(NonZeroUsize::new),
         }
     }
 
-    delegate_access_inner!(stream, St, (. .));
+    delegate_access_inner!(stream, St, (.));
 }
 
 impl<St> Stream for TryBufferUnordered<St>
@@ -54,7 +53,7 @@ where
         // our queue of futures. Propagate errors from the stream immediately.
         while this.max.map(|max| this.in_progress_queue.len() < max.get()).unwrap_or(true) {
             match this.stream.as_mut().poll_next(cx)? {
-                Poll::Ready(Some(fut)) => this.in_progress_queue.push(fut.into_future()),
+                Poll::Ready(Some(fut)) => this.in_progress_queue.push(fut),
                 Poll::Ready(None) | Poll::Pending => break,
             }
         }