Remove futures_[un]ordered functions

Author: taiki-e

futures-util/src/stream/futures_ordered.rs

@@ -85,8 +85,8 @@ impl<T> Future for OrderWrapper<T>
 /// some of the later futures have already completed.
 ///
 /// Note that you can create a ready-made `FuturesOrdered` via the
-/// `futures_ordered` function in the `stream` module, or you can start with an
-/// empty queue with the `FuturesOrdered::new` constructor.
+/// [`collect`](Iterator::collect) method, or you can start with an empty queue
+/// with the `FuturesOrdered::new` constructor.
 #[must_use = "streams do nothing unless polled"]
 pub struct FuturesOrdered<T: Future> {
     in_progress_queue: FuturesUnordered<OrderWrapper<T>>,
@@ -97,25 +97,6 @@ pub struct FuturesOrdered<T: Future> {
 
 impl<T: Future> Unpin for FuturesOrdered<T> {}
 
-/// Converts a list of futures into a `Stream` of results from the futures.
-///
-/// This function will take a list of futures (e.g. a vector, an iterator,
-/// etc), and return a stream. The stream will yield items as they become
-/// available on the futures internally, in the order that their originating
-/// futures were submitted to the queue. If the futures complete out of order,
-/// items will be stored internally within `FuturesOrdered` until all preceding
-/// items have been yielded.
-///
-/// Note that the returned queue can also be used to dynamically push more
-/// futures into the queue as they become available.
-pub fn futures_ordered<I>(futures: I) -> FuturesOrdered<I::Item>
-where
-    I: IntoIterator,
-    I::Item: Future,
-{
-    futures.into_iter().collect()
-}
-
 impl<Fut: Future> FuturesOrdered<Fut> {
     /// Constructs a new, empty `FuturesOrdered`
     ///

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

@@ -19,7 +19,7 @@ use alloc::sync::{Arc, Weak};
 mod abort;
 
 mod iter;
-use self::iter::{IterMut, IterPinMut};
+pub use self::iter::{IterMut, IterPinMut};
 
 mod task;
 use self::task::Task;
@@ -51,8 +51,8 @@ const TERMINATED_SENTINEL_LENGTH: usize = usize::max_value();
 /// wake-ups for new futures.
 ///
 /// Note that you can create a ready-made [`FuturesUnordered`] via the
-/// [`futures_unordered`](futures_unordered()) function, or you can start with
-/// an empty set with the [`FuturesUnordered::new`] constructor.
+/// [`collect`](Iterator::collect) method, or you can start with an empty set
+/// with the [`FuturesUnordered::new`] constructor.
 #[must_use = "streams do nothing unless polled"]
 pub struct FuturesUnordered<Fut> {
     ready_to_run_queue: Arc<ReadyToRunQueue<Fut>>,
@@ -469,25 +469,6 @@ impl<Fut: Future> FromIterator<Fut> for FuturesUnordered<Fut> {
     }
 }
 
-/// Converts a list of futures into a [`Stream`] of outputs from the futures.
-///
-/// This function will take a list of futures (e.g. a [`Vec`], an [`Iterator`],
-/// etc), and return a stream. The stream will yield items as they become
-/// available on the futures internally, in the order that they become
-/// available. This function is similar to
-/// [`buffer_unordered`](super::StreamExt::buffer_unordered) in that it may
-/// return items in a different order than in the list specified.
-///
-/// Note that the returned set can also be used to dynamically push more
-/// futures into the set as they become available.
-pub fn futures_unordered<I>(futures: I) -> FuturesUnordered<I::Item>
-where
-    I: IntoIterator,
-    I::Item: Future,
-{
-    futures.into_iter().collect()
-}
-
 impl<Fut: Future> FusedStream for FuturesUnordered<Fut> {
     fn is_terminated(&self) -> bool {
         self.len == TERMINATED_SENTINEL_LENGTH

futures-util/src/stream/mod.rs

@@ -123,12 +123,13 @@ cfg_target_has_atomic! {
     #[cfg(feature = "alloc")]
     mod futures_ordered;
     #[cfg(feature = "alloc")]
-    pub use self::futures_ordered::{futures_ordered, FuturesOrdered};
+    pub use self::futures_ordered::FuturesOrdered;
 
     #[cfg(feature = "alloc")]
-    mod futures_unordered;
+    pub mod futures_unordered;
     #[cfg(feature = "alloc")]
-    pub use self::futures_unordered::{futures_unordered, FuturesUnordered};
+    #[doc(inline)]
+    pub use self::futures_unordered::FuturesUnordered;
 
     #[cfg(feature = "alloc")]
     mod split;

futures/src/lib.rs

@@ -322,10 +322,8 @@ pub mod stream {
     //!   asynchronously produce a sequence of values.
     //! - The [`StreamExt`](crate::stream::StreamExt) trait, which provides
     //!   adapters for chaining and composing streams.
-    //! - Top-level stream contructors like [`iter_ok`](crate::stream::iter)
-    //!   which creates a stream from an iterator, and
-    //!   [`futures_unordered`](crate::stream::futures_unordered()), which
-    //!   constructs a stream from a collection of futures.
+    //! - Top-level stream contructors like [`iter`](crate::stream::iter)
+    //!   which creates a stream from an iterator.
 
     pub use futures_core::stream::{
         Stream, TryStream, FusedStream,
@@ -358,7 +356,7 @@ pub mod stream {
     )]
     #[cfg(feature = "alloc")]
     pub use futures_util::stream::{
-        futures_ordered, FuturesOrdered,
+        FuturesOrdered,
         futures_unordered, FuturesUnordered,
 
         // For StreamExt: