stream: use current_thread flavor instead of futures::executor::block_on

Author: lblack00

tokio-stream/Cargo.toml

@@ -46,7 +46,7 @@ tokio = { version = "1.2.0", path = "../tokio", features = ["full", "test-util"]
 async-stream = "0.3"
 parking_lot = "0.12.0"
 tokio-test = { version = "0.4", path = "../tokio-test" }
-futures = { version = "0.3", default-features = false, features = ["executor"] }
+futures = { version = "0.3", default-features = false }
 
 [package.metadata.docs.rs]
 all-features = true

tokio-stream/src/empty.rs

@@ -24,21 +24,17 @@ unsafe impl<T> Sync for Empty<T> {}
 /// Basic usage:
 ///
 /// ```
-/// # use futures::executor::block_on;
 /// use tokio_stream::{self as stream, StreamExt};
 ///
 /// # /*
 /// #[tokio::main]
-/// async fn main() {
 /// # */
-/// # block_on(async {
+/// # #[tokio::main(flavor = "current_thread")]
+/// async fn main() {
 ///     let mut none = stream::empty::<i32>();
 ///
 ///     assert_eq!(None, none.next().await);
-/// # })
-/// # /*
 /// }
-/// # */
 /// ```
 pub const fn empty<T>() -> Empty<T> {
     Empty(PhantomData)

tokio-stream/src/lib.rs

@@ -32,23 +32,19 @@
 //! `while let` loop as follows:
 //!
 //! ```rust
-//! # use futures::executor::block_on;
 //! use tokio_stream::{self as stream, StreamExt};
 //!
 //! # /*
 //! #[tokio::main]
-//! async fn main() {
 //! # */
-//! # block_on(async {
+//! # #[tokio::main(flavor = "current_thread")]
+//! async fn main() {
 //!     let mut stream = stream::iter(vec![0, 1, 2]);
 //!
 //!     while let Some(value) = stream.next().await {
 //!         println!("Got {}", value);
 //!     }
-//! # })
-//! # /*
 //! }
-//! # */
 //! ```
 //!
 //! # Returning a Stream from a function

tokio-stream/src/once.rs

@@ -20,25 +20,21 @@ impl<I> Unpin for Once<I> {}
 /// # Examples
 ///
 /// ```
-/// # use futures::executor::block_on;
 /// use tokio_stream::{self as stream, StreamExt};
 ///
 /// # /*
 /// #[tokio::main]
-/// async fn main() {
 /// # */
-/// # block_on(async {
+/// # #[tokio::main(flavor = "current_thread")]
+/// async fn main() {
 ///     // one is the loneliest number
 ///     let mut one = stream::once(1);
 ///
 ///     assert_eq!(Some(1), one.next().await);
 ///
 ///     // just one, that's all we get
 ///     assert_eq!(None, one.next().await);
-/// # })
-/// # /*
 /// }
-/// # */
 /// ```
 pub fn once<T>(value: T) -> Once<T> {
     Once {

tokio-stream/src/stream_close.rs

@@ -15,14 +15,13 @@ pin_project! {
     /// Using `StreamNotifyClose` to handle closed streams with `StreamMap`.
     ///
     /// ```
-    /// # use futures::executor::block_on;
     /// use tokio_stream::{StreamExt, StreamMap, StreamNotifyClose};
     ///
     /// # /*
     /// #[tokio::main]
-    /// async fn main() {
     /// # */
-    /// # block_on(async {
+    /// # #[tokio::main(flavor = "current_thread")]
+    /// async fn main() {
     ///     let mut map = StreamMap::new();
     ///     let stream = StreamNotifyClose::new(tokio_stream::iter(vec![0, 1]));
     ///     let stream2 = StreamNotifyClose::new(tokio_stream::iter(vec![0, 1]));
@@ -34,10 +33,7 @@ pin_project! {
     ///             None => println!("stream {key:?} closed"),
     ///         }
     ///     }
-    /// # })
-    /// # /*
     /// }
-    /// # */
     /// ```
     #[must_use = "streams do nothing unless polled"]
     pub struct StreamNotifyClose<S> {