Change StreamExt::select to a function

Author: taiki-e

futures-util/src/stream/mod.rs

@@ -79,7 +79,7 @@ mod poll_fn;
 pub use self::poll_fn::{poll_fn, PollFn};
 
 mod select;
-pub use self::select::Select;
+pub use self::select::{select, Select};
 
 mod skip;
 pub use self::skip::Skip;
@@ -1014,23 +1014,6 @@ pub trait StreamExt: Stream {
         Chunks::new(self, capacity)
     }
 
-    /// This combinator will attempt to pull items from both streams. Each
-    /// stream will be polled in a round-robin fashion, and whenever a stream is
-    /// ready to yield an item that item is yielded.
-    ///
-    /// After one of the two input stream completes, the remaining one will be
-    /// polled exclusively. The returned stream completes when both input
-    /// streams have completed.
-    ///
-    /// Note that this method consumes both streams and returns a wrapped
-    /// version of them.
-    fn select<St>(self, other: St) -> Select<Self, St>
-        where St: Stream<Item = Self::Item>,
-              Self: Sized,
-    {
-        Select::new(self, other)
-    }
-
     /// A future that completes after the given stream has been fully processed
     /// into the sink and the sink has been flushed and closed.
     ///

futures-util/src/stream/select.rs

@@ -3,7 +3,7 @@ use core::pin::Pin;
 use futures_core::stream::{FusedStream, Stream};
 use futures_core::task::{Context, Poll};
 
-/// Stream for the [`select`](super::StreamExt::select) method.
+/// Stream for the [`select`](super::StreamExt::select) function.
 #[derive(Debug)]
 #[must_use = "streams do nothing unless polled"]
 pub struct Select<St1, St2> {
@@ -14,16 +14,24 @@ pub struct Select<St1, St2> {
 
 impl<St1: Unpin, St2: Unpin> Unpin for Select<St1, St2> {}
 
-impl<St1, St2> Select<St1, St2>
+/// This function will attempt to pull items from both streams. Each
+/// stream will be polled in a round-robin fashion, and whenever a stream is
+/// ready to yield an item that item is yielded.
+///
+/// After one of the two input stream completes, the remaining one will be
+/// polled exclusively. The returned stream completes when both input
+/// streams have completed.
+///
+/// Note that this function consumes both streams and returns a wrapped
+/// version of them.
+pub fn select<St1, St2>(stream1: St1, stream2: St2) -> Select<St1, St2>
     where St1: Stream,
           St2: Stream<Item = St1::Item>
 {
-    pub(super) fn new(stream1: St1, stream2: St2) -> Select<St1, St2> {
-        Select {
-            stream1: stream1.fuse(),
-            stream2: stream2.fuse(),
-            flag: false,
-        }
+    Select {
+        stream1: stream1.fuse(),
+        stream2: stream2.fuse(),
+        flag: false,
     }
 }
 

futures/src/lib.rs

@@ -342,12 +342,13 @@ pub mod stream {
         empty, Empty,
         once, Once,
         poll_fn, PollFn,
+        select, Select,
         unfold, Unfold,
 
         StreamExt,
         Chain, Collect, Concat, Enumerate, Filter, FilterMap, Flatten, Fold,
         Forward, ForEach, Fuse, StreamFuture, Inspect, Map, Next,
-        SelectNextSome, Peekable, Select, Skip, SkipWhile, Take, TakeWhile,
+        SelectNextSome, Peekable, Skip, SkipWhile, Take, TakeWhile,
         Then, Zip
     };
 

futures/tests/stream.rs

@@ -12,7 +12,7 @@ fn select() {
     fn select_and_compare(a: Vec<u32>, b: Vec<u32>, expected: Vec<u32>) {
         let a = stream::iter(a);
         let b = stream::iter(b);
-        let vec = block_on(a.select(b).collect::<Vec<_>>());
+        let vec = block_on(stream::select(a, b).collect::<Vec<_>>());
         assert_eq!(vec, expected);
     }