Use async block in more examples

Author: taiki-e

futures-executor/src/local_pool.rs

@@ -132,10 +132,9 @@ impl LocalPool {
     ///
     /// ```
     /// use futures::executor::LocalPool;
-    /// use futures::future::ready;
     ///
     /// let mut pool = LocalPool::new();
-    /// # let my_app  = ready(());
+    /// # let my_app  = async {};
     ///
     /// // run tasks in the pool until `my_app` completes, by default spawning
     /// // further tasks back onto the pool

futures-util/src/async_await/join_mod.rs

@@ -20,10 +20,10 @@ macro_rules! document_join_macro {
         ///
         /// ```
         /// # futures::executor::block_on(async {
-        /// use futures::{join, future};
+        /// use futures::join;
         ///
-        /// let a = future::ready(1);
-        /// let b = future::ready(2);
+        /// let a = async { 1 };
+        /// let b = async { 2 };
         ///
         /// assert_eq!(join!(a, b), (1, 2));
         /// # });
@@ -47,10 +47,10 @@ macro_rules! document_join_macro {
         ///
         /// ```
         /// # futures::executor::block_on(async {
-        /// use futures::{try_join, future};
+        /// use futures::try_join;
         ///
-        /// let a = future::ready(Ok::<i32, i32>(1));
-        /// let b = future::ready(Ok::<u64, i32>(2));
+        /// let a = async { Ok::<i32, i32>(1) };
+        /// let b = async { Ok::<u64, i32>(2) };
         ///
         /// assert_eq!(try_join!(a, b), Ok((1, 2)));
         /// # });
@@ -61,10 +61,10 @@ macro_rules! document_join_macro {
         ///
         /// ```
         /// # futures::executor::block_on(async {
-        /// use futures::{try_join, future};
+        /// use futures::try_join;
         ///
-        /// let a = future::ready(Ok::<i32, i32>(1));
-        /// let b = future::ready(Err::<u64, i32>(2));
+        /// let a = async { Ok::<i32, i32>(1) };
+        /// let b = async { Err::<u64, i32>(2) };
         ///
         /// assert_eq!(try_join!(a, b), Err(2));
         /// # });

futures-util/src/future/abortable.rs

@@ -30,10 +30,10 @@ impl<Fut> Abortable<Fut> where Fut: Future {
     ///
     /// ```
     /// # futures::executor::block_on(async {
-    /// use futures::future::{ready, Abortable, AbortHandle, Aborted};
+    /// use futures::future::{Abortable, AbortHandle, Aborted};
     ///
     /// let (abort_handle, abort_registration) = AbortHandle::new_pair();
-    /// let future = Abortable::new(ready(2), abort_registration);
+    /// let future = Abortable::new(async { 2 }, abort_registration);
     /// abort_handle.abort();
     /// assert_eq!(future.await, Err(Aborted));
     /// # });
@@ -70,10 +70,10 @@ impl AbortHandle {
     ///
     /// ```
     /// # futures::executor::block_on(async {
-    /// use futures::future::{ready, Abortable, AbortHandle, Aborted};
+    /// use futures::future::{Abortable, AbortHandle, Aborted};
     ///
     /// let (abort_handle, abort_registration) = AbortHandle::new_pair();
-    /// let future = Abortable::new(ready(2), abort_registration);
+    /// let future = Abortable::new(async { 2 }, abort_registration);
     /// abort_handle.abort();
     /// assert_eq!(future.await, Err(Aborted));
     /// # });

futures-util/src/future/join.rs

@@ -93,8 +93,8 @@ generate! {
 /// # futures::executor::block_on(async {
 /// use futures::future;
 ///
-/// let a = future::ready(1);
-/// let b = future::ready(2);
+/// let a = async { 1 };
+/// let b = async { 2 };
 /// let pair = future::join(a, b);
 ///
 /// assert_eq!(pair.await, (1, 2));
@@ -117,9 +117,9 @@ where
 /// # futures::executor::block_on(async {
 /// use futures::future;
 ///
-/// let a = future::ready(1);
-/// let b = future::ready(2);
-/// let c = future::ready(3);
+/// let a = async { 1 };
+/// let b = async { 2 };
+/// let c = async { 3 };
 /// let tuple = future::join3(a, b, c);
 ///
 /// assert_eq!(tuple.await, (1, 2, 3));
@@ -146,10 +146,10 @@ where
 /// # futures::executor::block_on(async {
 /// use futures::future;
 ///
-/// let a = future::ready(1);
-/// let b = future::ready(2);
-/// let c = future::ready(3);
-/// let d = future::ready(4);
+/// let a = async { 1 };
+/// let b = async { 2 };
+/// let c = async { 3 };
+/// let d = async { 4 };
 /// let tuple = future::join4(a, b, c, d);
 ///
 /// assert_eq!(tuple.await, (1, 2, 3, 4));
@@ -178,11 +178,11 @@ where
 /// # futures::executor::block_on(async {
 /// use futures::future;
 ///
-/// let a = future::ready(1);
-/// let b = future::ready(2);
-/// let c = future::ready(3);
-/// let d = future::ready(4);
-/// let e = future::ready(5);
+/// let a = async { 1 };
+/// let b = async { 2 };
+/// let c = async { 3 };
+/// let d = async { 4 };
+/// let e = async { 5 };
 /// let tuple = future::join5(a, b, c, d, e);
 ///
 /// assert_eq!(tuple.await, (1, 2, 3, 4, 5));

futures-util/src/future/join_all.rs

@@ -103,7 +103,7 @@ where
 ///
 /// ```
 /// # futures::executor::block_on(async {
-/// use futures::future::{join_all};
+/// use futures::future::join_all;
 ///
 /// async fn foo(i: u32) -> u32 { i }
 ///

futures-util/src/future/maybe_done.rs

@@ -31,7 +31,7 @@ impl<Fut: Future + Unpin> Unpin for MaybeDone<Fut> {}
 /// use futures::future;
 /// use futures::pin_mut;
 ///
-/// let future = future::maybe_done(future::ready(5));
+/// let future = future::maybe_done(async { 5 });
 /// pin_mut!(future);
 /// assert_eq!(future.as_mut().take_output(), None);
 /// let () = future.as_mut().await;

futures-util/src/future/mod.rs

@@ -127,9 +127,9 @@ pub trait FutureExt: Future {
     ///
     /// ```
     /// # futures::executor::block_on(async {
-    /// use futures::future::{self, FutureExt};
+    /// use futures::future::FutureExt;
     ///
-    /// let future = future::ready(1);
+    /// let future = async { 1 };
     /// let new_future = future.map(|x| x + 3);
     /// assert_eq!(new_future.await, 4);
     /// # });
@@ -158,10 +158,10 @@ pub trait FutureExt: Future {
     ///
     /// ```
     /// # futures::executor::block_on(async {
-    /// use futures::future::{self, FutureExt};
+    /// use futures::future::FutureExt;
     ///
-    /// let future_of_1 = future::ready(1);
-    /// let future_of_4 = future_of_1.then(|x| future::ready(x + 3));
+    /// let future_of_1 = async { 1 };
+    /// let future_of_4 = future_of_1.then(|x| async move { x + 3 });
     /// assert_eq!(future_of_4.await, 4);
     /// # });
     /// ```
@@ -183,13 +183,13 @@ pub trait FutureExt: Future {
     ///
     /// ```
     /// # futures::executor::block_on(async {
-    /// use futures::future::{self, FutureExt};
+    /// use futures::future::FutureExt;
     ///
     /// let x = 6;
     /// let future = if x < 10 {
-    ///     future::ready(true).left_future()
+    ///     async { true }.left_future()
     /// } else {
-    ///     future::ready(false).right_future()
+    ///     async { false }.right_future()
     /// };
     ///
     /// assert_eq!(future.await, true);
@@ -212,13 +212,13 @@ pub trait FutureExt: Future {
     ///
     /// ```
     /// # futures::executor::block_on(async {
-    /// use futures::future::{self, FutureExt};
+    /// use futures::future::FutureExt;
     ///
     /// let x = 6;
     /// let future = if x > 10 {
-    ///     future::ready(true).left_future()
+    ///     async { true }.left_future()
     /// } else {
-    ///     future::ready(false).right_future()
+    ///     async { false }.right_future()
     /// };
     ///
     /// assert_eq!(future.await, false);
@@ -240,10 +240,10 @@ pub trait FutureExt: Future {
     ///
     /// ```
     /// # futures::executor::block_on(async {
-    /// use futures::future::{self, FutureExt};
+    /// use futures::future::FutureExt;
     /// use futures::stream::StreamExt;
     ///
-    /// let future = future::ready(17);
+    /// let future = async { 17 };
     /// let stream = future.into_stream();
     /// let collected: Vec<_> = stream.collect().await;
     /// assert_eq!(collected, vec![17]);
@@ -273,9 +273,9 @@ pub trait FutureExt: Future {
     ///
     /// ```
     /// # futures::executor::block_on(async {
-    /// use futures::future::{self, FutureExt};
+    /// use futures::future::FutureExt;
     ///
-    /// let nested_future = future::ready(future::ready(1));
+    /// let nested_future = async { async { 1 } };
     /// let future = nested_future.flatten();
     /// assert_eq!(future.await, 1);
     /// # });
@@ -302,11 +302,11 @@ pub trait FutureExt: Future {
     ///
     /// ```
     /// # futures::executor::block_on(async {
-    /// use futures::future::{self, FutureExt};
+    /// use futures::future::FutureExt;
     /// use futures::stream::{self, StreamExt};
     ///
     /// let stream_items = vec![17, 18, 19];
-    /// let future_of_a_stream = future::ready(stream::iter(stream_items));
+    /// let future_of_a_stream = async { stream::iter(stream_items) };
     ///
     /// let stream = future_of_a_stream.flatten_stream();
     /// let list: Vec<_> = stream.collect().await;
@@ -354,9 +354,9 @@ pub trait FutureExt: Future {
     ///
     /// ```
     /// # futures::executor::block_on(async {
-    /// use futures::future::{self, FutureExt};
+    /// use futures::future::FutureExt;
     ///
-    /// let future = future::ready(1);
+    /// let future = async { 1 };
     /// let new_future = future.inspect(|&x| println!("about to resolve: {}", x));
     /// assert_eq!(new_future.await, 1);
     /// # });
@@ -420,9 +420,9 @@ pub trait FutureExt: Future {
     ///
     /// ```
     /// # futures::executor::block_on(async {
-    /// use futures::future::{self, FutureExt};
+    /// use futures::future::FutureExt;
     ///
-    /// let future = future::ready(6);
+    /// let future = async { 6 };
     /// let shared1 = future.shared();
     /// let shared2 = shared1.clone();
     ///
@@ -437,11 +437,11 @@ pub trait FutureExt: Future {
     /// // the `shared` combinator.
     ///
     /// # futures::executor::block_on(async {
-    /// use futures::future::{self, FutureExt};
+    /// use futures::future::FutureExt;
     /// use futures::executor::block_on;
     /// use std::thread;
     ///
-    /// let future = future::ready(6);
+    /// let future = async { 6 };
     /// let shared1 = future.shared();
     /// let shared2 = shared1.clone();
     /// let join_handle = thread::spawn(move || {

futures-util/src/future/option.rs

@@ -13,9 +13,9 @@ use pin_utils::unsafe_pinned;
 ///
 /// ```
 /// # futures::executor::block_on(async {
-/// use futures::future::{self, OptionFuture};
+/// use futures::future::OptionFuture;
 ///
-/// let mut a: OptionFuture<_> = Some(future::ready(123)).into();
+/// let mut a: OptionFuture<_> = Some(async { 123 }).into();
 /// assert_eq!(a.await, Some(123));
 ///
 /// a = None.into();

futures-util/src/stream/mod.rs

@@ -355,13 +355,11 @@ pub trait StreamExt: Stream {
     /// # Examples
     /// ```
     /// # futures::executor::block_on(async {
-    /// use futures::future;
     /// use futures::stream::{self, StreamExt};
     ///
     /// let stream = stream::iter(1..=10);
-    /// let evens = stream.filter_map(|x| {
-    ///     let ret = if x % 2 == 0 { Some(x + 1) } else { None };
-    ///     future::ready(ret)
+    /// let evens = stream.filter_map(|x| async move {
+    ///     if x % 2 == 0 { Some(x + 1) } else { None }
     /// });
     ///
     /// assert_eq!(vec![3, 5, 7, 9, 11], evens.collect::<Vec<_>>().await);
@@ -389,11 +387,10 @@ pub trait StreamExt: Stream {
     ///
     /// ```
     /// # futures::executor::block_on(async {
-    /// use futures::future;
     /// use futures::stream::{self, StreamExt};
     ///
     /// let stream = stream::iter(1..=3);
-    /// let stream = stream.then(|x| future::ready(x + 3));
+    /// let stream = stream.then(|x| async move { x + 3 });
     ///
     /// assert_eq!(vec![4, 5, 6], stream.collect::<Vec<_>>().await);
     /// # });
@@ -490,11 +487,10 @@ pub trait StreamExt: Stream {
     ///
     /// ```
     /// # futures::executor::block_on(async {
-    /// use futures::future;
     /// use futures::stream::{self, StreamExt};
     ///
     /// let number_stream = stream::iter(0..6);
-    /// let sum = number_stream.fold(0, |acc, x| future::ready(acc + x));
+    /// let sum = number_stream.fold(0, |acc, x| async move { acc + x });
     /// assert_eq!(sum.await, 15);
     /// # });
     /// ```
@@ -804,20 +800,19 @@ pub trait StreamExt: Stream {
     ///
     /// ```
     /// # futures::executor::block_on(async {
-    /// use futures::future;
     /// use futures::stream::{self, StreamExt};
     ///
     /// let mut stream = stream::iter(1..5);
     ///
     /// let sum = stream.by_ref()
     ///                 .take(2)
-    ///                 .fold(0, |a, b| future::ready(a + b))
+    ///                 .fold(0, |a, b| async move { a + b })
     ///                 .await;
     /// assert_eq!(sum, 3);
     ///
     /// // You can use the stream again
     /// let sum = stream.take(2)
-    ///                 .fold(0, |a, b| future::ready(a + b))
+    ///                 .fold(0, |a, b| async move { a + b })
     ///                 .await;
     /// assert_eq!(sum, 7);
     /// # });

futures-util/src/stream/once.rs

@@ -8,10 +8,9 @@ use pin_utils::unsafe_pinned;
 ///
 /// ```
 /// # futures::executor::block_on(async {
-/// use futures::future;
 /// use futures::stream::{self, StreamExt};
 ///
-/// let stream = stream::once(future::ready(17));
+/// let stream = stream::once(async { 17 });
 /// let collected = stream.collect::<Vec<i32>>().await;
 /// assert_eq!(collected, vec![17]);
 /// # });

futures-util/src/stream/unfold.rs

@@ -32,16 +32,15 @@ use pin_utils::{unsafe_pinned, unsafe_unpinned};
 ///
 /// ```
 /// # futures::executor::block_on(async {
-/// use futures::future;
 /// use futures::stream::{self, StreamExt};
 ///
-/// let stream = stream::unfold(0, |state| {
+/// let stream = stream::unfold(0, |state| async move {
 ///     if state <= 2 {
 ///         let next_state = state + 1;
 ///         let yielded = state  * 2;
-///         future::ready(Some((yielded, next_state)))
+///         Some((yielded, next_state))
 ///     } else {
-///         future::ready(None)
+///         None
 ///     }
 /// });
 ///