stream: make stream adapters public (#6658)

Author: sharpened-nacho

tokio-stream/src/lib.rs

@@ -81,8 +81,22 @@ pub mod wrappers;
 
 mod stream_ext;
 pub use stream_ext::{collect::FromStream, StreamExt};
+/// Adapters for [`Stream`]s created by methods in [`StreamExt`].
+pub mod adapters {
+    pub use crate::stream_ext::{
+        Chain, Filter, FilterMap, Fuse, Map, MapWhile, Merge, Peekable, Skip, SkipWhile, Take,
+        TakeWhile, Then,
+    };
+    cfg_time! {
+        pub use crate::stream_ext::{ChunksTimeout, Timeout, TimeoutRepeating};
+    }
+}
+
 cfg_time! {
-    pub use stream_ext::timeout::{Elapsed, Timeout};
+    #[deprecated = "Import those symbols from adapters instead"]
+    #[doc(hidden)]
+    pub use stream_ext::timeout::Timeout;
+    pub use stream_ext::timeout::Elapsed;
 }
 
 mod empty;

tokio-stream/src/stream_ext.rs

@@ -8,66 +8,66 @@ mod any;
 use any::AnyFuture;
 
 mod chain;
-use chain::Chain;
+pub use chain::Chain;
 
 pub(crate) mod collect;
 use collect::{Collect, FromStream};
 
 mod filter;
-use filter::Filter;
+pub use filter::Filter;
 
 mod filter_map;
-use filter_map::FilterMap;
+pub use filter_map::FilterMap;
 
 mod fold;
 use fold::FoldFuture;
 
 mod fuse;
-use fuse::Fuse;
+pub use fuse::Fuse;
 
 mod map;
-use map::Map;
+pub use map::Map;
 
 mod map_while;
-use map_while::MapWhile;
+pub use map_while::MapWhile;
 
 mod merge;
-use merge::Merge;
+pub use merge::Merge;
 
 mod next;
 use next::Next;
 
 mod skip;
-use skip::Skip;
+pub use skip::Skip;
 
 mod skip_while;
-use skip_while::SkipWhile;
+pub use skip_while::SkipWhile;
 
 mod take;
-use take::Take;
+pub use take::Take;
 
 mod take_while;
-use take_while::TakeWhile;
+pub use take_while::TakeWhile;
 
 mod then;
-use then::Then;
+pub use then::Then;
 
 mod try_next;
 use try_next::TryNext;
 
 mod peekable;
-use peekable::Peekable;
+pub use peekable::Peekable;
 
 cfg_time! {
     pub(crate) mod timeout;
     pub(crate) mod timeout_repeating;
-    use timeout::Timeout;
-    use timeout_repeating::TimeoutRepeating;
+    pub use timeout::Timeout;
+    pub use timeout_repeating::TimeoutRepeating;
     use tokio::time::{Duration, Interval};
     mod throttle;
     use throttle::{throttle, Throttle};
     mod chunks_timeout;
-    use chunks_timeout::ChunksTimeout;
+    pub use chunks_timeout::ChunksTimeout;
 }
 
 /// An extension trait for the [`Stream`] trait that provides a variety of

tokio-stream/tests/stream_chain.rs

@@ -6,13 +6,14 @@ mod support {
 }
 
 use support::mpsc;
+use tokio_stream::adapters::Chain;
 
 #[tokio::test]
 async fn basic_usage() {
     let one = stream::iter(vec![1, 2, 3]);
     let two = stream::iter(vec![4, 5, 6]);
 
-    let mut stream = one.chain(two);
+    let mut stream = visibility_test(one, two);
 
     assert_eq!(stream.size_hint(), (6, Some(6)));
     assert_eq!(stream.next().await, Some(1));
@@ -39,6 +40,14 @@ async fn basic_usage() {
     assert_eq!(stream.next().await, None);
 }
 
+fn visibility_test<I, S1, S2>(s1: S1, s2: S2) -> Chain<S1, S2>
+where
+    S1: Stream<Item = I>,
+    S2: Stream<Item = I>,
+{
+    s1.chain(s2)
+}
+
 #[tokio::test]
 async fn pending_first() {
     let (tx1, rx1) = mpsc::unbounded_channel_stream();