DOC-5760 added async content

Author: andy-stark-redis

content/develop/clients/hiredis/_index.md

@@ -12,7 +12,7 @@ categories:
 description: Connect your C application to a Redis database.
 linkTitle: hiredis (C)
 title: hiredis guide (C)
-weight: 9
+weight: 10
 ---
 
 [`hiredis`](https://github.com/redis/hiredis) is the

content/develop/clients/rust/_index.md

@@ -26,34 +26,50 @@ client library and is not developed or supported directly by Redis.
 
 ## Install
 
-Add the `redis` crate as a dependency in your `Cargo.toml` file:
+To use the synchronous API, add the `redis` crate as a dependency in your
+`Cargo.toml` file:
 
 ```toml
 [dependencies]
 redis = "0.32.5"
 ```
 
+If you want to use the asynchronous API, you should also enable either
+[`tokio`](https://tokio.rs/) or [`smol`](https://crates.io/crates/smol)
+as your async platform:
+
+```toml
+[dependencies]
+# if you use tokio
+tokio = { version = "1.32.0", features = ["full"] }
+redis = { version = "0.32.5", features = ["tokio-comp"] }
+
+# if you use smol
+smol = "2.0.2"
+redis = { version = "0.32.5", features = ["smol-comp"] }
+```
+
 ## Connect
 
-Start by importing the `Commands` trait from the `redis` crate:
+Start by importing the `Commands` or `AsyncCommands` trait from the `redis` crate:
 
-{{< clients-example set="landing" step="import" lang_filter="Rust-Sync" >}}
+{{< clients-example set="landing" step="import" lang_filter="Rust-Sync,Rust-Async" >}}
 {{< /clients-example >}}
 
 The following example shows the simplest way to connect to a Redis server:
 
-{{< clients-example set="landing" step="connect" lang_filter="Rust-Sync" >}}
+{{< clients-example set="landing" step="connect" lang_filter="Rust-Sync,Rust-Async" >}}
 {{< /clients-example >}}
 
 After connecting, you can test the connection by  storing and retrieving
 a simple [string]({{< relref "/develop/data-types/strings" >}}):
 
-{{< clients-example set="landing" step="set_get_string" lang_filter="Rust-Sync" >}}
+{{< clients-example set="landing" step="set_get_string" lang_filter="Rust-Sync,Rust-Async" >}}
 {{< /clients-example >}}
 
 You can also easily store and retrieve a [hash]({{< relref "/develop/data-types/hashes" >}}):
 
-{{< clients-example set="landing" step="set_get_hash" lang_filter="Rust-Sync" >}}
+{{< clients-example set="landing" step="set_get_hash" lang_filter="Rust-Sync,Rust-Async" >}}
 {{< /clients-example >}}
 
 ## More information

local_examples/client-specific/rust-async/landing.rs

@@ -0,0 +1,100 @@
+// EXAMPLE: landing
+// STEP_START import
+use redis::AsyncCommands;
+// STEP_END
+
+#[tokio::main]
+async fn main() {
+    // STEP_START connect
+    let mut r = match redis::Client::open("redis://127.0.0.1") {
+        Ok(client) => {
+            match client.get_multiplexed_async_connection().await {
+                Ok(conn) => conn,
+                Err(e) => {
+                    println!("Failed to connect to Redis: {e}");
+                    return;
+                }
+            }
+        },
+        Err(e) => {
+            println!("Failed to create Redis client: {e}");
+            return;
+        }
+    };
+    // STEP_END
+
+    // STEP_START set_get_string
+    if let Ok(res) = r.set("foo", "bar").await {
+        let res: String = res;
+        println!("{res}"); // >>> OK
+    } else {
+        println!("Error setting foo");
+    }
+
+    match r.get("foo").await {
+        Ok(res) => {
+            let res: String = res;
+            println!("{res}"); // >>> bar
+        },
+        Err(e) => {
+            println!("Error getting foo: {e}");
+            return;
+        }
+    };
+    // STEP_END
+
+    // STEP_START set_get_hash
+    let hash_fields = [
+        ("model", "Deimos"),
+        ("brand", "Ergonom"),
+        ("type", "Enduro bikes"),
+        ("price", "4972"),
+    ];
+
+    if let Ok(res) = r.hset_multiple("bike:1", &hash_fields).await {
+        let res: String = res;
+        println!("{res}"); // >>> OK
+    } else {
+        println!("Error setting bike:1");
+    }
+
+    match r.hget("bike:1", "model").await {
+        Ok(res) => {
+            let res: String = res;
+            println!("{res}"); // >>> Deimos
+        },
+        Err(e) => {
+            println!("Error getting bike:1 model: {e}");
+            return;
+        }
+    }
+
+    match r.hget("bike:1", "price").await {
+        Ok(res) => {
+            let res: String = res;
+            println!("{res}"); // >>> 4972
+        },
+        Err(e) => {
+            println!("Error getting bike:1 price: {e}");
+            return;
+        }
+    }
+
+    match r.hgetall("bike:1").await {
+        Ok(res) => {
+            let res: Vec<(String, String)> = res;
+            for (key, value) in res {
+                println!("{key}: {value}");
+            }
+            // >>> model: Deimos
+            // >>> brand: Ergonom
+            // >>> type: Enduro bikes
+            // >>> price: 4972
+        },
+        Err(e) => {
+            println!("Error getting bike:1: {e}");
+            return;
+        }
+        // STEP_END
+    }
+}

local_examples/client-specific/rust/landing.rs renamed to local_examples/client-specific/rust-sync/landing.rs

@@ -10,13 +10,13 @@ fn main() {
             match client.get_connection() {
                 Ok(conn) => conn,
                 Err(e) => {
-                    println!("Failed to connect to Redis: {}", e);
+                    println!("Failed to connect to Redis: {e}");
                     return;
                 }
             }
         },
         Err(e) => {
-            println!("Failed to create Redis client: {}", e);
+            println!("Failed to create Redis client: {e}");
             return;
         }
     };
@@ -25,18 +25,18 @@ fn main() {
     // STEP_START set_get_string
     if let Ok(res) = r.set("foo", "bar") {
         let res: String = res;
-        println!("{}", res);    // >>> OK
+        println!("{res}"); // >>> OK
     } else {
         println!("Error setting foo");
     }
 
     match r.get("foo") {
         Ok(res) => {
             let res: String = res;
-            println!("{}", res);   // >>> bar
+            println!("{res}"); // >>> bar
         },
         Err(e) => {
-            println!("Error getting foo: {}", e);
+            println!("Error getting foo: {e}");
             return;
         }
     };
@@ -52,29 +52,29 @@ fn main() {
 
     if let Ok(res) = r.hset_multiple("bike:1", &hash_fields) {
         let res: String = res;
-        println!("{}", res); // >>> OK
+        println!("{res}"); // >>> OK
     } else {
         println!("Error setting bike:1");
     }
 
     match r.hget("bike:1", "model") {
         Ok(res) => {
             let res: String = res;
-            println!("{}", res); // >>> Deimos
+            println!("{res}"); // >>> Deimos
         },
         Err(e) => {
-            println!("Error getting bike:1: {}", e);
+            println!("Error getting bike:1 model: {e}");
             return;
         }   
     }
 
     match r.hget("bike:1", "price") {
         Ok(res) => {
             let res: String = res;
-            println!("{}", res); // >>> 4972
+            println!("{res}"); // >>> 4972
         },
         Err(e) => {
-            println!("Error getting bike:1: {}", e);
+            println!("Error getting bike:1 price: {e}");
             return;
         }   
     }
@@ -83,15 +83,15 @@ fn main() {
         Ok(res) => {
             let res: Vec<(String, String)> = res;
             for (key, value) in res {
-                println!("{}: {}", key, value);
+                println!("{key}: {value}");
             }
             // >>> model: Deimos
             // >>> brand: Ergonom
             // >>> type: Enduro bikes
             // >>> price: 4972
         },
         Err(e) => {
-            println!("Error getting bike:1: {}", e);
+            println!("Error getting bike:1: {e}");
             return;
         }   
     }