From 90c83b8faca107e6c4db63d10b0d4f2ea36d6628 Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Sat, 31 Aug 2019 03:58:08 +0900 Subject: [PATCH] Use async block in more examples --- futures-executor/src/local_pool.rs | 3 +- futures-util/src/async_await/join_mod.rs | 18 +++---- futures-util/src/future/abortable.rs | 8 +-- futures-util/src/future/join.rs | 28 +++++------ futures-util/src/future/join_all.rs | 2 +- futures-util/src/future/maybe_done.rs | 2 +- futures-util/src/future/mod.rs | 46 +++++++++--------- futures-util/src/future/option.rs | 4 +- futures-util/src/stream/mod.rs | 17 +++---- futures-util/src/stream/once.rs | 3 +- futures-util/src/stream/unfold.rs | 7 ++- futures-util/src/task/spawn.rs | 3 +- futures-util/src/try_future/mod.rs | 62 ++++++++++++------------ futures-util/src/try_stream/mod.rs | 15 +++--- futures/tests/macro_comma_support.rs | 2 +- 15 files changed, 105 insertions(+), 115 deletions(-) diff --git a/futures-executor/src/local_pool.rs b/futures-executor/src/local_pool.rs index 8bf7246266..78ba2c3493 100644 --- a/futures-executor/src/local_pool.rs +++ b/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 diff --git a/futures-util/src/async_await/join_mod.rs b/futures-util/src/async_await/join_mod.rs index c10e990039..a2dbad9aa4 100644 --- a/futures-util/src/async_await/join_mod.rs +++ b/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::(1)); - /// let b = future::ready(Ok::(2)); + /// let a = async { Ok::(1) }; + /// let b = async { Ok::(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::(1)); - /// let b = future::ready(Err::(2)); + /// let a = async { Ok::(1) }; + /// let b = async { Err::(2) }; /// /// assert_eq!(try_join!(a, b), Err(2)); /// # }); diff --git a/futures-util/src/future/abortable.rs b/futures-util/src/future/abortable.rs index 7085041c9b..3c57cfc01d 100644 --- a/futures-util/src/future/abortable.rs +++ b/futures-util/src/future/abortable.rs @@ -30,10 +30,10 @@ impl Abortable 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)); /// # }); diff --git a/futures-util/src/future/join.rs b/futures-util/src/future/join.rs index 77dcd0b66a..5e984b8439 100644 --- a/futures-util/src/future/join.rs +++ b/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)); diff --git a/futures-util/src/future/join_all.rs b/futures-util/src/future/join_all.rs index 62bf467c26..07408856a4 100644 --- a/futures-util/src/future/join_all.rs +++ b/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 } /// diff --git a/futures-util/src/future/maybe_done.rs b/futures-util/src/future/maybe_done.rs index 09ce81ea33..f16f889781 100644 --- a/futures-util/src/future/maybe_done.rs +++ b/futures-util/src/future/maybe_done.rs @@ -31,7 +31,7 @@ impl Unpin for MaybeDone {} /// 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; diff --git a/futures-util/src/future/mod.rs b/futures-util/src/future/mod.rs index fa4795df76..4cd04a57cc 100644 --- a/futures-util/src/future/mod.rs +++ b/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 || { diff --git a/futures-util/src/future/option.rs b/futures-util/src/future/option.rs index 788ae469fa..e14745e9d4 100644 --- a/futures-util/src/future/option.rs +++ b/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(); diff --git a/futures-util/src/stream/mod.rs b/futures-util/src/stream/mod.rs index 1ce75ee121..a6cd6fc1a8 100644 --- a/futures-util/src/stream/mod.rs +++ b/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::>().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::>().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); /// # }); diff --git a/futures-util/src/stream/once.rs b/futures-util/src/stream/once.rs index d9d1512b52..8dc6ed6ab7 100644 --- a/futures-util/src/stream/once.rs +++ b/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::>().await; /// assert_eq!(collected, vec![17]); /// # }); diff --git a/futures-util/src/stream/unfold.rs b/futures-util/src/stream/unfold.rs index 4774a70f4f..223f64576f 100644 --- a/futures-util/src/stream/unfold.rs +++ b/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 /// } /// }); /// diff --git a/futures-util/src/task/spawn.rs b/futures-util/src/task/spawn.rs index 0c2731100c..e869f1ef55 100644 --- a/futures-util/src/task/spawn.rs +++ b/futures-util/src/task/spawn.rs @@ -136,13 +136,12 @@ pub trait LocalSpawnExt: LocalSpawn { /// /// ``` /// use futures::executor::LocalPool; - /// use futures::future; /// use futures::task::LocalSpawnExt; /// /// let mut executor = LocalPool::new(); /// let mut spawner = executor.spawner(); /// - /// let future = future::ready(1); + /// let future = async { 1 }; /// let join_handle_fut = spawner.spawn_local_with_handle(future).unwrap(); /// assert_eq!(executor.run_until(join_handle_fut), 1); /// ``` diff --git a/futures-util/src/try_future/mod.rs b/futures-util/src/try_future/mod.rs index 90d481aee0..82bba47640 100644 --- a/futures-util/src/try_future/mod.rs +++ b/futures-util/src/try_future/mod.rs @@ -136,10 +136,10 @@ pub trait TryFutureExt: TryFuture { /// # Examples /// /// ``` - /// use futures::future::{self, TryFutureExt}; + /// use futures::future::TryFutureExt; /// /// # futures::executor::block_on(async { - /// let future = future::ready(Ok::(1)); + /// let future = async { Ok::(1) }; /// let future = future.map_ok(|x| x + 3); /// assert_eq!(future.await, Ok(4)); /// # }); @@ -149,10 +149,10 @@ pub trait TryFutureExt: TryFuture { /// effect: /// /// ``` - /// use futures::future::{self, TryFutureExt}; + /// use futures::future::TryFutureExt; /// /// # futures::executor::block_on(async { - /// let future = future::ready(Err::(1)); + /// let future = async { Err::(1) }; /// let future = future.map_ok(|x| x + 3); /// assert_eq!(future.await, Err(1)); /// # }); @@ -182,10 +182,10 @@ pub trait TryFutureExt: TryFuture { /// # Examples /// /// ``` - /// use futures::future::{self, TryFutureExt}; + /// use futures::future::TryFutureExt; /// /// # futures::executor::block_on(async { - /// let future = future::ready(Err::(1)); + /// let future = async { Err::(1) }; /// let future = future.map_err(|x| x + 3); /// assert_eq!(future.await, Err(4)); /// # }); @@ -195,10 +195,10 @@ pub trait TryFutureExt: TryFuture { /// no effect: /// /// ``` - /// use futures::future::{self, TryFutureExt}; + /// use futures::future::TryFutureExt; /// /// # futures::executor::block_on(async { - /// let future = future::ready(Ok::(1)); + /// let future = async { Ok::(1) }; /// let future = future.map_err(|x| x + 3); /// assert_eq!(future.await, Ok(1)); /// # }); @@ -225,10 +225,10 @@ pub trait TryFutureExt: TryFuture { /// # Examples /// /// ``` - /// use futures::future::{self, TryFutureExt}; + /// use futures::future::TryFutureExt; /// /// # futures::executor::block_on(async { - /// let future_err_u8 = future::ready(Err::<(), u8>(1)); + /// let future_err_u8 = async { Err::<(), u8>(1) }; /// let future_err_i32 = future_err_u8.err_into::(); /// # }); /// ``` @@ -254,11 +254,11 @@ pub trait TryFutureExt: TryFuture { /// # Examples /// /// ``` - /// use futures::future::{self, TryFutureExt}; + /// use futures::future::TryFutureExt; /// /// # futures::executor::block_on(async { - /// let future = future::ready(Ok::(1)); - /// let future = future.and_then(|x| future::ready(Ok::(x + 3))); + /// let future = async { Ok::(1) }; + /// let future = future.and_then(|x| async move { Ok::(x + 3) }); /// assert_eq!(future.await, Ok(4)); /// # }); /// ``` @@ -267,11 +267,11 @@ pub trait TryFutureExt: TryFuture { /// effect: /// /// ``` - /// use futures::future::{self, TryFutureExt}; + /// use futures::future::TryFutureExt; /// /// # futures::executor::block_on(async { - /// let future = future::ready(Err::(1)); - /// let future = future.and_then(|x| future::ready(Err::(x + 3))); + /// let future = async { Err::(1) }; + /// let future = future.and_then(|x| async move { Err::(x + 3) }); /// assert_eq!(future.await, Err(1)); /// # }); /// ``` @@ -298,11 +298,11 @@ pub trait TryFutureExt: TryFuture { /// # Examples /// /// ``` - /// use futures::future::{self, TryFutureExt}; + /// use futures::future::TryFutureExt; /// /// # futures::executor::block_on(async { - /// let future = future::ready(Err::(1)); - /// let future = future.or_else(|x| future::ready(Err::(x + 3))); + /// let future = async { Err::(1) }; + /// let future = future.or_else(|x| async move { Err::(x + 3) }); /// assert_eq!(future.await, Err(4)); /// # }); /// ``` @@ -311,11 +311,11 @@ pub trait TryFutureExt: TryFuture { /// no effect: /// /// ``` - /// use futures::future::{self, TryFutureExt}; + /// use futures::future::TryFutureExt; /// /// # futures::executor::block_on(async { - /// let future = future::ready(Ok::(1)); - /// let future = future.or_else(|x| future::ready(Ok::(x + 3))); + /// let future = async { Ok::(1) }; + /// let future = future.or_else(|x| async move { Ok::(x + 3) }); /// assert_eq!(future.await, Ok(1)); /// # }); /// ``` @@ -338,9 +338,9 @@ pub trait TryFutureExt: TryFuture { /// /// ``` /// # futures::executor::block_on(async { - /// use futures::future::{self, TryFutureExt}; + /// use futures::future::TryFutureExt; /// - /// let future = future::ok::<_, ()>(1); + /// let future = async { Ok::<_, ()>(1) }; /// let new_future = future.inspect_ok(|&x| println!("about to resolve: {}", x)); /// assert_eq!(new_future.await, Ok(1)); /// # }); @@ -363,9 +363,9 @@ pub trait TryFutureExt: TryFuture { /// /// ``` /// # futures::executor::block_on(async { - /// use futures::future::{self, TryFutureExt}; + /// use futures::future::TryFutureExt; /// - /// let future = future::err::<(), _>(1); + /// let future = async { Err::<(), _>(1) }; /// let new_future = future.inspect_err(|&x| println!("about to error: {}", x)); /// assert_eq!(new_future.await, Err(1)); /// # }); @@ -391,11 +391,11 @@ pub trait TryFutureExt: TryFuture { /// /// ``` /// # futures::executor::block_on(async { - /// use futures::future::{self, TryFutureExt}; + /// use futures::future::TryFutureExt; /// use futures::stream::{self, TryStreamExt}; /// /// let stream_items = vec![17, 18, 19].into_iter().map(Ok); - /// let future_of_a_stream = future::ok::<_, ()>(stream::iter(stream_items)); + /// let future_of_a_stream = async { Ok::<_, ()>(stream::iter(stream_items)) }; /// /// let stream = future_of_a_stream.try_flatten_stream(); /// let list = stream.try_collect::>().await; @@ -423,10 +423,10 @@ pub trait TryFutureExt: TryFuture { /// # Examples /// /// ``` - /// use futures::future::{self, TryFutureExt}; + /// use futures::future::TryFutureExt; /// /// # futures::executor::block_on(async { - /// let future = future::ready(Err::<(), &str>("Boom!")); + /// let future = async { Err::<(), &str>("Boom!") }; /// let future = future.unwrap_or_else(|_| ()); /// assert_eq!(future.await, ()); /// # }); @@ -462,7 +462,7 @@ pub trait TryFutureExt: TryFuture { /// # type T = i32; /// # type E = (); /// fn make_try_future() -> impl TryFuture { // ... } - /// # futures::future::ready(Ok::(1)) + /// # async { Ok::(1) } /// # } /// fn take_future(future: impl Future>) { /* ... */ } /// diff --git a/futures-util/src/try_stream/mod.rs b/futures-util/src/try_stream/mod.rs index 819b498ebe..d1f46117f2 100644 --- a/futures-util/src/try_stream/mod.rs +++ b/futures-util/src/try_stream/mod.rs @@ -529,15 +529,16 @@ pub trait TryStreamExt: TryStream { /// # Examples /// ``` /// # futures::executor::block_on(async { - /// use futures::future; /// use futures::stream::{self, StreamExt, TryStreamExt}; + /// use futures::pin_mut; /// /// let stream = stream::iter(vec![Ok(1i32), Ok(6i32), Err("error")]); - /// let mut halves = stream.try_filter_map(|x| { + /// let halves = stream.try_filter_map(|x| async move { /// let ret = if x % 2 == 0 { Some(x / 2) } else { None }; - /// future::ready(Ok(ret)) + /// Ok(ret) /// }); /// + /// pin_mut!(halves); /// assert_eq!(halves.next().await, Some(Ok(3))); /// assert_eq!(halves.next().await, Some(Err("error"))); /// # }) @@ -613,15 +614,14 @@ pub trait TryStreamExt: TryStream { /// /// ``` /// # futures::executor::block_on(async { - /// use futures::future; /// use futures::stream::{self, TryStreamExt}; /// /// let number_stream = stream::iter(vec![Ok::(1), Ok(2)]); - /// let sum = number_stream.try_fold(0, |acc, x| future::ready(Ok(acc + x))); + /// let sum = number_stream.try_fold(0, |acc, x| async move { Ok(acc + x) }); /// assert_eq!(sum.await, Ok(3)); /// /// let number_stream_with_err = stream::iter(vec![Ok::(1), Err(2), Ok(1)]); - /// let sum = number_stream_with_err.try_fold(0, |acc, x| future::ready(Ok(acc + x))); + /// let sum = number_stream_with_err.try_fold(0, |acc, x| async move { Ok(acc + x) }); /// assert_eq!(sum.await, Err(2)); /// # }) /// ``` @@ -720,13 +720,12 @@ pub trait TryStreamExt: TryStream { /// ``` /// # futures::executor::block_on(async { /// use futures::channel::mpsc; - /// use futures::future; /// use futures::stream::{StreamExt, TryStreamExt}; /// /// let (sink, stream_of_futures) = mpsc::unbounded(); /// let mut buffered = stream_of_futures.try_buffer_unordered(10); /// - /// sink.unbounded_send(Ok(future::ready(Ok(7i32))))?; + /// sink.unbounded_send(Ok(async { Ok(7i32) }))?; /// assert_eq!(buffered.next().await, Some(Ok(7i32))); /// /// sink.unbounded_send(Err("error in the stream"))?; diff --git a/futures/tests/macro_comma_support.rs b/futures/tests/macro_comma_support.rs index 1c6eea07fe..111f65af4e 100644 --- a/futures/tests/macro_comma_support.rs +++ b/futures/tests/macro_comma_support.rs @@ -18,7 +18,7 @@ fn ready() { #[test] fn poll() { block_on(async { - let _ = poll!(async { () }.boxed(),); + let _ = poll!(async {}.boxed(),); }) }