Use .await syntax

Signed-off-by: Nick Cameron <nrc@ncameron.org>

Author: nrc

examples/raw.rs

@@ -27,14 +27,14 @@ async fn main() -> Result<()> {
     // When we first create a client we receive a `Connect` structure which must be resolved before
     // the client is actually connected and usable.
     let unconnnected_client = Client::new(config);
-    let client = await!(unconnnected_client)?;
+    let client = unconnnected_client.await?;
 
     // Requests are created from the connected client. These calls return structures which
     // implement `Future`. This means the `Future` must be resolved before the action ever takes
     // place.
     //
     // Here we set the key `TiKV` to have the value `Rust` associated with it.
-    await!(client.put(KEY, VALUE)).unwrap(); // Returns a `tikv_client::Error` on failure.
+    client.put(KEY, VALUE).await.unwrap(); // Returns a `tikv_client::Error` on failure.
     println!("Put key {:?}, value {:?}.", KEY, VALUE);
 
     // Unlike a standard Rust HashMap all calls take owned values. This is because under the hood
@@ -46,17 +46,20 @@ async fn main() -> Result<()> {
     //
     // It is best to pass a `Vec<u8>` in terms of explictness and speed. `String`s and a few other
     // types are supported as well, but it all ends up as `Vec<u8>` in the end.
-    let value: Option<Value> = await!(client.get(KEY))?;
+    let value: Option<Value> = client.get(KEY).await?;
     assert_eq!(value, Some(Value::from(VALUE)));
     println!("Get key {:?} returned value {:?}.", Key::from(KEY), value);
 
     // You can also set the `ColumnFamily` used by the request.
     // This is *advanced usage* and should have some special considerations.
-    await!(client.delete(KEY)).expect("Could not delete value");
+    client.delete(KEY).await.expect("Could not delete value");
     println!("Key: {:?} deleted", Key::from(KEY));
 
     // Here we check if the key has been deleted from the key-value store.
-    let value: Option<Value> = await!(client.get(KEY)).expect("Could not get just deleted entry");
+    let value: Option<Value> = client
+        .get(KEY)
+        .await
+        .expect("Could not get just deleted entry");
     assert!(value.is_none());
 
     // You can ask to write multiple key-values at the same time, it is much more
@@ -66,18 +69,25 @@ async fn main() -> Result<()> {
         KvPair::from(("k2", "v2")),
         KvPair::from(("k3", "v3")),
     ];
-    await!(client.batch_put(pairs)).expect("Could not put pairs");
+    client.batch_put(pairs).await.expect("Could not put pairs");
 
     // Same thing when you want to retrieve multiple values.
     let keys = vec![Key::from("k1"), Key::from("k2")];
-    let values = await!(client.batch_get(keys.clone())).expect("Could not get values");
+    let values = client
+        .batch_get(keys.clone())
+        .await
+        .expect("Could not get values");
     println!("Found values: {:?} for keys: {:?}", values, keys);
 
     // Scanning a range of keys is also possible giving it two bounds
     // it will returns all entries between these two.
     let start = "k1";
     let end = "k2";
-    let pairs = await!(client.scan(start..=end, 10).key_only()).expect("Could not scan");
+    let pairs = client
+        .scan(start..=end, 10)
+        .key_only()
+        .await
+        .expect("Could not scan");
 
     let keys: Vec<_> = pairs.into_iter().map(|p| p.key().clone()).collect();
     assert_eq!(&keys, &[Key::from("k1"), Key::from("k2")]);

examples/transaction.rs

@@ -18,27 +18,28 @@ use tikv_client::{
 
 async fn puts(client: &Client, pairs: impl IntoIterator<Item = impl Into<KvPair>>) {
     let mut txn = client.begin();
-    await!(future::join_all(
+    future::join_all(
         pairs
             .into_iter()
             .map(Into::into)
-            .map(|p| txn.set(p.key().clone(), p.value().clone()))
-    ))
+            .map(|p| txn.set(p.key().clone(), p.value().clone())),
+    )
+    .await
     .into_iter()
     .collect::<Result<Vec<()>, _>>()
     .expect("Could not set key value pairs");
-    await!(txn.commit()).expect("Could not commit transaction");
+    txn.commit().await.expect("Could not commit transaction");
 }
 
 async fn get(client: &Client, key: Key) -> Value {
     let txn = client.begin();
-    await!(txn.get(key)).expect("Could not get value")
+    txn.get(key).await.expect("Could not get value")
 }
 
 // Ignore a spurious warning from rustc (https://github.com/rust-lang/rust/issues/60566).
 #[allow(unused_mut)]
 async fn scan(client: &Client, range: impl RangeBounds<Key>, mut limit: usize) {
-    await!(client
+    client
         .begin()
         .scan(range)
         .into_stream()
@@ -51,18 +52,21 @@ async fn scan(client: &Client, range: impl RangeBounds<Key>, mut limit: usize) {
                 true
             })
         })
-        .for_each(|pair| { future::ready(println!("{:?}", pair)) }));
+        .for_each(|pair| future::ready(println!("{:?}", pair)))
+        .await;
 }
 
 async fn dels(client: &Client, keys: impl IntoIterator<Item = Key>) {
     let mut txn = client.begin();
     txn.set_isolation_level(IsolationLevel::ReadCommitted);
-    let _: Vec<()> = await!(stream::iter(keys.into_iter())
-        .then(|p| txn
-            .delete(p)
-            .unwrap_or_else(|e| panic!("error in delete: {:?}", e)))
-        .collect());
-    await!(txn.commit()).expect("Could not commit transaction");
+    let _: Vec<()> = stream::iter(keys.into_iter())
+        .then(|p| {
+            txn.delete(p)
+                .unwrap_or_else(|e| panic!("error in delete: {:?}", e))
+        })
+        .collect()
+        .await;
+    txn.commit().await.expect("Could not commit transaction");
 }
 
 #[runtime::main(runtime_tokio::Tokio)]
@@ -79,26 +83,28 @@ async fn main() {
         Config::new(args.pd)
     };
 
-    let txn = await!(Client::new(config)).expect("Could not connect to tikv");
+    let txn = Client::new(config)
+        .await
+        .expect("Could not connect to tikv");
 
     // set
     let key1: Key = b"key1".to_vec().into();
     let value1: Value = b"value1".to_vec().into();
     let key2: Key = b"key2".to_vec().into();
     let value2: Value = b"value2".to_vec().into();
-    await!(puts(&txn, vec![(key1, value1), (key2, value2)]));
+    puts(&txn, vec![(key1, value1), (key2, value2)]).await;
 
     // get
     let key1: Key = b"key1".to_vec().into();
-    let value1 = await!(get(&txn, key1.clone()));
+    let value1 = get(&txn, key1.clone()).await;
     println!("{:?}", (key1, value1));
 
     // scan
     let key1: Key = b"key1".to_vec().into();
-    await!(scan(&txn, key1.., 10));
+    scan(&txn, key1.., 10).await;
 
     // delete
     let key1: Key = b"key1".to_vec().into();
     let key2: Key = b"key2".to_vec().into();
-    await!(dels(&txn, vec![key1, key2]));
+    dels(&txn, vec![key1, key2]).await;
 }

src/lib.rs

@@ -81,7 +81,7 @@
 //! ([raw](raw/struct.Client.html), [transactional](transaction/struct.Client.html)).
 //!
 //! ```rust
-//! # #![feature(async_await, await_macro)]
+//! # #![feature(async_await)]
 //! # use tikv_client::{*, raw::*};
 //! # use futures::prelude::*;
 //!
@@ -96,7 +96,7 @@
 //! let connect = Client::new(config);
 //!
 //! // Resolve the connection into a client.
-//! let client = await!(connect.into_future());
+//! let client = connect.into_future().await;
 //! # });
 //! ```
 //!

src/raw.rs

@@ -29,12 +29,12 @@ impl Client {
     /// Create a new [`Client`](struct.Client.html) once the [`Connect`](struct.Connect.html) resolves.
     ///
     /// ```rust,no_run
-    /// # #![feature(async_await, await_macro)]
+    /// # #![feature(async_await)]
     /// # use tikv_client::{Config, raw::Client};
     /// # use futures::prelude::*;
     /// # futures::executor::block_on(async {
     /// let connect = Client::new(Config::default());
-    /// let client = await!(connect).unwrap();
+    /// let client = connect.await.unwrap();
     /// # });
     /// ```
     #[cfg_attr(feature = "cargo-clippy", allow(clippy::new_ret_no_self))]
@@ -53,15 +53,15 @@ impl Client {
     /// given key.
     ///
     /// ```rust,no_run
-    /// # #![feature(async_await, await_macro)]
+    /// # #![feature(async_await)]
     /// # use tikv_client::{Value, Config, raw::Client};
     /// # use futures::prelude::*;
     /// # futures::executor::block_on(async {
     /// # let connecting_client = Client::new(Config::new(vec!["192.168.0.100", "192.168.0.101"]));
-    /// # let connected_client = await!(connecting_client).unwrap();
+    /// # let connected_client = connecting_client.await.unwrap();
     /// let key = "TiKV";
     /// let req = connected_client.get(key);
-    /// let result: Option<Value> = await!(req).unwrap();
+    /// let result: Option<Value> = req.await.unwrap();
     /// # });
     /// ```
     pub fn get(&self, key: impl Into<Key>) -> Get {
@@ -74,15 +74,15 @@ impl Client {
     /// given keys.
     ///
     /// ```rust,no_run
-    /// # #![feature(async_await, await_macro)]
+    /// # #![feature(async_await)]
     /// # use tikv_client::{KvPair, Config, raw::Client};
     /// # use futures::prelude::*;
     /// # futures::executor::block_on(async {
     /// # let connecting_client = Client::new(Config::new(vec!["192.168.0.100", "192.168.0.101"]));
-    /// # let connected_client = await!(connecting_client).unwrap();
+    /// # let connected_client = connecting_client.await.unwrap();
     /// let keys = vec!["TiKV", "TiDB"];
     /// let req = connected_client.batch_get(keys);
-    /// let result: Vec<KvPair> = await!(req).unwrap();
+    /// let result: Vec<KvPair> = req.await.unwrap();
     /// # });
     /// ```
     pub fn batch_get(&self, keys: impl IntoIterator<Item = impl Into<Key>>) -> BatchGet {
@@ -97,16 +97,16 @@ impl Client {
     /// Once resolved this request will result in the setting of the value associated with the given key.
     ///
     /// ```rust,no_run
-    /// # #![feature(async_await, await_macro)]
+    /// # #![feature(async_await)]
     /// # use tikv_client::{Key, Value, Config, raw::Client};
     /// # use futures::prelude::*;
     /// # futures::executor::block_on(async {
     /// # let connecting_client = Client::new(Config::new(vec!["192.168.0.100", "192.168.0.101"]));
-    /// # let connected_client = await!(connecting_client).unwrap();
+    /// # let connected_client = connecting_client.await.unwrap();
     /// let key = "TiKV";
     /// let val = "TiKV";
     /// let req = connected_client.put(key, val);
-    /// let result: () = await!(req).unwrap();
+    /// let result: () = req.await.unwrap();
     /// # });
     /// ```
     pub fn put(&self, key: impl Into<Key>, value: impl Into<Value>) -> Put {
@@ -118,17 +118,17 @@ impl Client {
     /// Once resolved this request will result in the setting of the value associated with the given key.
     ///
     /// ```rust,no_run
-    /// # #![feature(async_await, await_macro)]
+    /// # #![feature(async_await)]
     /// # use tikv_client::{Error, Result, KvPair, Key, Value, Config, raw::Client};
     /// # use futures::prelude::*;
     /// # futures::executor::block_on(async {
     /// # let connecting_client = Client::new(Config::new(vec!["192.168.0.100", "192.168.0.101"]));
-    /// # let connected_client = await!(connecting_client).unwrap();
+    /// # let connected_client = connecting_client.await.unwrap();
     /// let kvpair1 = ("PD", "Go");
     /// let kvpair2 = ("TiKV", "Rust");
     /// let iterable = vec![kvpair1, kvpair2];
     /// let req = connected_client.batch_put(iterable);
-    /// let result: () = await!(req).unwrap();
+    /// let result: () = req.await.unwrap();
     /// # });
     /// ```
     pub fn batch_put(&self, pairs: impl IntoIterator<Item = impl Into<KvPair>>) -> BatchPut {
@@ -143,15 +143,15 @@ impl Client {
     /// Once resolved this request will result in the deletion of the given key.
     ///
     /// ```rust,no_run
-    /// # #![feature(async_await, await_macro)]
+    /// # #![feature(async_await)]
     /// # use tikv_client::{Key, Config, raw::Client};
     /// # use futures::prelude::*;
     /// # futures::executor::block_on(async {
     /// # let connecting_client = Client::new(Config::new(vec!["192.168.0.100", "192.168.0.101"]));
-    /// # let connected_client = await!(connecting_client).unwrap();
+    /// # let connected_client = connecting_client.await.unwrap();
     /// let key = "TiKV";
     /// let req = connected_client.delete(key);
-    /// let result: () = await!(req).unwrap();
+    /// let result: () = req.await.unwrap();
     /// # });
     /// ```
     pub fn delete(&self, key: impl Into<Key>) -> Delete {
@@ -163,15 +163,15 @@ impl Client {
     /// Once resolved this request will result in the deletion of the given keys.
     ///
     /// ```rust,no_run
-    /// # #![feature(async_await, await_macro)]
+    /// # #![feature(async_await)]
     /// # use tikv_client::{Config, raw::Client};
     /// # use futures::prelude::*;
     /// # futures::executor::block_on(async {
     /// # let connecting_client = Client::new(Config::new(vec!["192.168.0.100", "192.168.0.101"]));
-    /// # let connected_client = await!(connecting_client).unwrap();
+    /// # let connected_client = connecting_client.await.unwrap();
     /// let keys = vec!["TiKV", "TiDB"];
     /// let req = connected_client.batch_delete(keys);
-    /// let result: () = await!(req).unwrap();
+    /// let result: () = req.await.unwrap();
     /// # });
     /// ```
     pub fn batch_delete(&self, keys: impl IntoIterator<Item = impl Into<Key>>) -> BatchDelete {
@@ -186,15 +186,15 @@ impl Client {
     /// Once resolved this request will result in a scanner over the given keys.
     ///
     /// ```rust,no_run
-    /// # #![feature(async_await, await_macro)]
+    /// # #![feature(async_await)]
     /// # use tikv_client::{KvPair, Config, raw::Client};
     /// # use futures::prelude::*;
     /// # futures::executor::block_on(async {
     /// # let connecting_client = Client::new(Config::new(vec!["192.168.0.100", "192.168.0.101"]));
-    /// # let connected_client = await!(connecting_client).unwrap();
+    /// # let connected_client = connecting_client.await.unwrap();
     /// let inclusive_range = "TiKV"..="TiDB";
     /// let req = connected_client.scan(inclusive_range, 2);
-    /// let result: Vec<KvPair> = await!(req).unwrap();
+    /// let result: Vec<KvPair> = req.await.unwrap();
     /// # });
     /// ```
     pub fn scan(&self, range: impl KeyRange, limit: u32) -> Scan {
@@ -206,17 +206,17 @@ impl Client {
     /// Once resolved this request will result in a set of scanners over the given keys.
     ///
     /// ```rust,no_run
-    /// # #![feature(async_await, await_macro)]
+    /// # #![feature(async_await)]
     /// # use tikv_client::{Key, Config, raw::Client};
     /// # use futures::prelude::*;
     /// # futures::executor::block_on(async {
     /// # let connecting_client = Client::new(Config::new(vec!["192.168.0.100", "192.168.0.101"]));
-    /// # let connected_client = await!(connecting_client).unwrap();
+    /// # let connected_client = connecting_client.await.unwrap();
     /// let inclusive_range1 = "TiDB"..="TiKV";
     /// let inclusive_range2 = "TiKV"..="TiSpark";
     /// let iterable = vec![inclusive_range1, inclusive_range2];
     /// let req = connected_client.batch_scan(iterable, 2);
-    /// let result = await!(req);
+    /// let result = req.await;
     /// # });
     /// ```
     pub fn batch_scan(
@@ -238,15 +238,15 @@ impl Client {
     /// Once resolved this request will result in the deletion of all keys over the given range.
     ///
     /// ```rust,no_run
-    /// # #![feature(async_await, await_macro)]
+    /// # #![feature(async_await)]
     /// # use tikv_client::{Key, Config, raw::Client};
     /// # use futures::prelude::*;
     /// # futures::executor::block_on(async {
     /// # let connecting_client = Client::new(Config::new(vec!["192.168.0.100", "192.168.0.101"]));
-    /// # let connected_client = await!(connecting_client).unwrap();
+    /// # let connected_client = connecting_client.await.unwrap();
     /// let inclusive_range = "TiKV"..="TiDB";
     /// let req = connected_client.delete_range(inclusive_range);
-    /// let result: () = await!(req).unwrap();
+    /// let result: () = req.await.unwrap();
     /// # });
     /// ```
     pub fn delete_range(&self, range: impl KeyRange) -> DeleteRange {
@@ -259,13 +259,13 @@ impl Client {
 /// Once resolved it will result in a connected [`Client`](struct.Client.html).
 ///
 /// ```rust,no_run
-/// # #![feature(async_await, await_macro)]
+/// # #![feature(async_await)]
 /// use tikv_client::{Config, raw::{Client, Connect}};
 /// use futures::prelude::*;
 ///
 /// # futures::executor::block_on(async {
 /// let connect: Connect = Client::new(Config::default());
-/// let client: Client = await!(connect).unwrap();
+/// let client: Client = connect.await.unwrap();
 /// # });
 /// ```
 pub struct Connect {