EXISTS

import redis  r = redis.Redis(decode_responses=True)  res = r.set("key1", "Hello") print(res) # >>> True  res = r.set("key2", "World") print(res) # >>> True  res = r.delete("key1", "key2", "key3") print(res) # >>> 2  res = r.set("key1", "Hello") print(res) # >>> True  res = r.exists("key1") print(res) # >>> 1  res = r.exists("nosuchkey") print(res) # >>> 0  res = r.set("key2", "World") print(res) # >>> True  res = r.exists("key1", "key2", "nosuchkey") print(res) # >>> 2  res = r.set("mykey", "Hello") print(res) # >>> True  res = r.expire("mykey", 10) print(res) # >>> True  res = r.ttl("mykey") print(res) # >>> 10  res = r.set("mykey", "Hello World") print(res) # >>> True  res = r.ttl("mykey") print(res) # >>> -1  res = r.expire("mykey", 10, xx=True) print(res) # >>> False  res = r.ttl("mykey") print(res) # >>> -1  res = r.expire("mykey", 10, nx=True) print(res) # >>> True  res = r.ttl("mykey") print(res) # >>> 10  res = r.set("mykey", "Hello") print(res) # >>> True  res = r.expire("mykey", 10) print(res) # >>> True  res = r.ttl("mykey") print(res) # >>> 10  res = r.sadd("myset", *set([1, 2, 3, "foo", "foobar", "feelsgood"])) print(res) # >>> 6  res = list(r.sscan_iter("myset", match="f*")) print(res) # >>> ['foobar', 'foo', 'feelsgood']   cursor, key = r.scan(cursor=0, match='*11*') print(cursor, key)  cursor, key = r.scan(cursor, match='*11*') print(cursor, key)  cursor, key = r.scan(cursor, match='*11*') print(cursor, key)  cursor, key = r.scan(cursor, match='*11*') print(cursor, key)  cursor, keys = r.scan(cursor, match='*11*', count=1000) print(cursor, keys)   res = r.geoadd("geokey", (0, 0, "value")) print(res) # >>> 1  res = r.zadd("zkey", {"value": 1000}) print(res) # >>> 1  res = r.type("geokey") print(res) # >>> zset  res = r.type("zkey") print(res) # >>> zset  cursor, keys = r.scan(cursor=0, _type="zset") print(keys) # >>> ['zkey', 'geokey']  res = r.hset("myhash", mapping={"a": 1, "b": 2}) print(res) # >>> 2  cursor, keys = r.hscan("myhash", 0) print(keys) # >>> {'a': '1', 'b': '2'}  cursor, keys = r.hscan("myhash", 0, no_values=True) print(keys) # >>> ['a', 'b']  

 import { createClient } from 'redis';  const client = createClient(); await client.connect().catch(console.error);  const delRes1 = await client.set('key1', 'Hello'); console.log(delRes1); // OK  const delRes2 = await client.set('key2', 'World'); console.log(delRes2); // OK  const delRes3 = await client.del(['key1', 'key2', 'key3']); console.log(delRes3); // 2  const existsRes1 = await client.set('key1', 'Hello'); console.log(existsRes1); // OK  const existsRes2 = await client.exists('key1'); console.log(existsRes2); // 1  const existsRes3 = await client.exists('nosuchkey'); console.log(existsRes3); // 0  const existsRes4 = await client.set('key2', 'World'); console.log(existsRes4); // OK  const existsRes5 = await client.exists(['key1', 'key2', 'nosuchkey']); console.log(existsRes5); // 2  const expireRes1 = await client.set('mykey', 'Hello'); console.log(expireRes1); // OK  const expireRes2 = await client.expire('mykey', 10); console.log(expireRes2); // 1  const expireRes3 = await client.ttl('mykey'); console.log(expireRes3); // 10  const expireRes4 = await client.set('mykey', 'Hello World'); console.log(expireRes4); // OK  const expireRes5 = await client.ttl('mykey'); console.log(expireRes5); // -1  const expireRes6 = await client.expire('mykey', 10, "XX"); console.log(expireRes6); // 0  const expireRes7 = await client.ttl('mykey'); console.log(expireRes7); // -1  const expireRes8 = await client.expire('mykey', 10, "NX"); console.log(expireRes8); // 1  const expireRes9 = await client.ttl('mykey'); console.log(expireRes9); // 10  const ttlRes1 = await client.set('mykey', 'Hello'); console.log(ttlRes1); // OK  const ttlRes2 = await client.expire('mykey', 10); console.log(ttlRes2); // 1  const ttlRes3 = await client.ttl('mykey'); console.log(ttlRes3); // 10  const scan1Res1 = await client.sAdd('myset', ['1', '2', '3', 'foo', 'foobar', 'feelsgood']); console.log(scan1Res1); // 6  let scan1Res2 = []; for await (const values of client.sScanIterator('myset', { MATCH: 'f*' })) {  scan1Res2 = scan1Res2.concat(values); } console.log(scan1Res2); // ['foo', 'foobar', 'feelsgood']   let cursor = '0'; let scanResult;  scanResult = await client.scan(cursor, { MATCH: '*11*' }); console.log(scanResult.cursor, scanResult.keys);  scanResult = await client.scan(scanResult.cursor, { MATCH: '*11*' }); console.log(scanResult.cursor, scanResult.keys);  scanResult = await client.scan(scanResult.cursor, { MATCH: '*11*' }); console.log(scanResult.cursor, scanResult.keys);  scanResult = await client.scan(scanResult.cursor, { MATCH: '*11*' }); console.log(scanResult.cursor, scanResult.keys);  scanResult = await client.scan(scanResult.cursor, { MATCH: '*11*', COUNT: 1000 }); console.log(scanResult.cursor, scanResult.keys);  const scan3Res1 = await client.geoAdd('geokey', { longitude: 0, latitude: 0, member: 'value' }); console.log(scan3Res1); // 1  const scan3Res2 = await client.zAdd('zkey', [{ score: 1000, value: 'value' }]); console.log(scan3Res2); // 1  const scan3Res3 = await client.type('geokey'); console.log(scan3Res3); // zset  const scan3Res4 = await client.type('zkey'); console.log(scan3Res4); // zset  const scan3Res5 = await client.scan('0', { TYPE: 'zset' }); console.log(scan3Res5.keys); // ['zkey', 'geokey']  const scan4Res1 = await client.hSet('myhash', { a: 1, b: 2 }); console.log(scan4Res1); // 2  const scan4Res2 = await client.hScan('myhash', '0'); console.log(scan4Res2.entries); // [{field: 'a', value: '1'}, {field: 'b', value: '2'}]  const scan4Res3 = await client.hScan('myhash', '0', { COUNT: 10 }); const items = scan4Res3.entries.map((item) => item.field) console.log(items); // ['a', 'b']  await client.close(); 

 import redis.clients.jedis.UnifiedJedis; import redis.clients.jedis.args.ExpiryOption;  import static org.junit.jupiter.api.Assertions.assertEquals;  public class CmdsGenericExample {   public void run() {  UnifiedJedis jedis = new UnifiedJedis("redis://localhost:6379");    String delResult1 = jedis.set("key1", "Hello");  System.out.println(delResult1); // >>> OK   String delResult2 = jedis.set("key2", "World");  System.out.println(delResult2); // >>> OK   long delResult3 = jedis.del("key1", "key2", "key3");  System.out.println(delResult3); // >>> 2   // Tests for 'del' step.    String existsResult1 = jedis.set("key1", "Hello");  System.out.println(existsResult1); // >>> OK   boolean existsResult2 = jedis.exists("key1");  System.out.println(existsResult2); // >>> true   boolean existsResult3 = jedis.exists("nosuchkey");  System.out.println(existsResult3); // >>> false   String existsResult4 = jedis.set("key2", "World");  System.out.println(existsResult4); // >>> OK   long existsResult5 = jedis.exists("key1", "key2", "nosuchkey");  System.out.println(existsResult5); // >>> 2   // Tests for 'exists' step.    String expireResult1 = jedis.set("mykey", "Hello");  System.out.println(expireResult1); // >>> OK   long expireResult2 = jedis.expire("mykey", 10);  System.out.println(expireResult2); // >>> 1   long expireResult3 = jedis.ttl("mykey");  System.out.println(expireResult3); // >>> 10   String expireResult4 = jedis.set("mykey", "Hello World");  System.out.println(expireResult4); // >>> OK   long expireResult5 = jedis.ttl("mykey");  System.out.println(expireResult5); // >>> -1   long expireResult6 = jedis.expire("mykey", 10, ExpiryOption.XX);  System.out.println(expireResult6); // >>> 0   long expireResult7 = jedis.ttl("mykey");  System.out.println(expireResult7); // >>> -1   long expireResult8 = jedis.expire("mykey", 10, ExpiryOption.NX);  System.out.println(expireResult8); // >>> 1   long expireResult9 = jedis.ttl("mykey");  System.out.println(expireResult9); // >>> 10   // Tests for 'expire' step.    String ttlResult1 = jedis.set("mykey", "Hello");  System.out.println(ttlResult1); // >>> OK   long ttlResult2 = jedis.expire("mykey", 10);  System.out.println(ttlResult2); // >>> 1   long ttlResult3 = jedis.ttl("mykey");  System.out.println(ttlResult3); // >>> 10   // Tests for 'ttl' step.   jedis.close();  } } 

package io.redis.examples.async;  import io.lettuce.core.*;  import io.lettuce.core.api.async.RedisAsyncCommands;  import io.lettuce.core.api.StatefulRedisConnection;  import java.util.concurrent.CompletableFuture;  public class CmdsGenericExample {   public void run() {   CompletableFuture<Void> existsExample = asyncCommands.set("key1", "Hello").thenCompose(res1 -> {  System.out.println(res1); // >>> OK   return asyncCommands.exists("key1");  }).thenCompose(res2 -> {  System.out.println(res2); // >>> 1   return asyncCommands.exists("nosuchkey");  }).thenCompose(res3 -> {  System.out.println(res3); // >>> 0   return asyncCommands.set("key2", "World");  }).thenCompose(res4 -> {  System.out.println(res4); // >>> OK   return asyncCommands.exists("key1", "key2", "nosuchkey");  }).thenAccept(res5 -> {  System.out.println(res5); // >>> 2  }).toCompletableFuture();  existsExample.join();  } finally {  redisClient.shutdown();  }  } } 

package io.redis.examples.reactive;  import io.lettuce.core.*; import io.lettuce.core.api.reactive.RedisReactiveCommands; import io.lettuce.core.api.StatefulRedisConnection; import reactor.core.publisher.Mono;   public class CmdsGenericExample {   public void run() {  RedisClient redisClient = RedisClient.create("redis://localhost:6379");   try (StatefulRedisConnection<String, String> connection = redisClient.connect()) {  RedisReactiveCommands<String, String> reactiveCommands = connection.reactive();   Mono<Void> existsExample = reactiveCommands.set("key1", "Hello").doOnNext(res1 -> {  System.out.println(res1); // >>> OK  }).then(reactiveCommands.exists("key1")).doOnNext(res2 -> {  System.out.println(res2); // >>> 1  }).then(reactiveCommands.exists("nosuchkey")).doOnNext(res3 -> {  System.out.println(res3); // >>> 0  }).then(reactiveCommands.set("key2", "World")).doOnNext(res4 -> {  System.out.println(res4); // >>> OK  }).then(reactiveCommands.exists("key1", "key2", "nosuchkey")).doOnNext(res5 -> {  System.out.println(res5); // >>> 2  }).then();   Mono.when(existsExample).block();   } finally {  redisClient.shutdown();  }  }  } 

package example_commands_test  import ( "context" "fmt" "math" "time"  "github.com/redis/go-redis/v9" )   func ExampleClient_del_cmd() { ctx := context.Background()  rdb := redis.NewClient(&redis.Options{ Addr: "localhost:6379", Password: "", // no password docs DB: 0, // use default DB })   delResult1, err := rdb.Set(ctx, "key1", "Hello", 0).Result()  if err != nil { panic(err) }  fmt.Println(delResult1) // >>> OK  delResult2, err := rdb.Set(ctx, "key2", "World", 0).Result()  if err != nil { panic(err) }  fmt.Println(delResult2) // >>> OK  delResult3, err := rdb.Del(ctx, "key1", "key2", "key3").Result()  if err != nil { panic(err) }  fmt.Println(delResult3) // >>> 2  }  func ExampleClient_exists_cmd() { ctx := context.Background()  rdb := redis.NewClient(&redis.Options{ Addr: "localhost:6379", Password: "", // no password docs DB: 0, // use default DB })   existsResult1, err := rdb.Set(ctx, "key1", "Hello", 0).Result()  if err != nil { panic(err) }  fmt.Println(existsResult1) // >>> OK  existsResult2, err := rdb.Exists(ctx, "key1").Result()  if err != nil { panic(err) }  fmt.Println(existsResult2) // >>> 1  existsResult3, err := rdb.Exists(ctx, "nosuchkey").Result()  if err != nil { panic(err) }  fmt.Println(existsResult3) // >>> 0  existsResult4, err := rdb.Set(ctx, "key2", "World", 0).Result()  if err != nil { panic(err) }  fmt.Println(existsResult4) // >>> OK  existsResult5, err := rdb.Exists(ctx, "key1", "key2", "nosuchkey").Result()  if err != nil { panic(err) }  fmt.Println(existsResult5) // >>> 2  }  func ExampleClient_expire_cmd() { ctx := context.Background()  rdb := redis.NewClient(&redis.Options{ Addr: "localhost:6379", Password: "", // no password docs DB: 0, // use default DB })   expireResult1, err := rdb.Set(ctx, "mykey", "Hello", 0).Result()  if err != nil { panic(err) }  fmt.Println(expireResult1) // >>> OK  expireResult2, err := rdb.Expire(ctx, "mykey", 10*time.Second).Result()  if err != nil { panic(err) }  fmt.Println(expireResult2) // >>> true  expireResult3, err := rdb.TTL(ctx, "mykey").Result()  if err != nil { panic(err) }  fmt.Println(math.Round(expireResult3.Seconds())) // >>> 10  expireResult4, err := rdb.Set(ctx, "mykey", "Hello World", 0).Result()  if err != nil { panic(err) }  fmt.Println(expireResult4) // >>> OK  expireResult5, err := rdb.TTL(ctx, "mykey").Result()  if err != nil { panic(err) }  fmt.Println(expireResult5) // >>> -1ns  expireResult6, err := rdb.ExpireXX(ctx, "mykey", 10*time.Second).Result()  if err != nil { panic(err) }  fmt.Println(expireResult6) // >>> false  expireResult7, err := rdb.TTL(ctx, "mykey").Result()  if err != nil { panic(err) }  fmt.Println(expireResult7) // >>> -1ns  expireResult8, err := rdb.ExpireNX(ctx, "mykey", 10*time.Second).Result()  if err != nil { panic(err) }  fmt.Println(expireResult8) // >>> true  expireResult9, err := rdb.TTL(ctx, "mykey").Result()  if err != nil { panic(err) }  fmt.Println(math.Round(expireResult9.Seconds())) // >>> 10  }  func ExampleClient_ttl_cmd() { ctx := context.Background()  rdb := redis.NewClient(&redis.Options{ Addr: "localhost:6379", Password: "", // no password docs DB: 0, // use default DB })   ttlResult1, err := rdb.Set(ctx, "mykey", "Hello", 10*time.Second).Result()  if err != nil { panic(err) }  fmt.Println(ttlResult1) // >>> OK  ttlResult2, err := rdb.TTL(ctx, "mykey").Result()  if err != nil { panic(err) }  fmt.Println(math.Round(ttlResult2.Seconds())) // >>> 10  } 

 using NRedisStack.Tests; using StackExchange.Redis;    public class CmdsGenericExample {  public void Run()  {  var muxer = ConnectionMultiplexer.Connect("localhost:6379");  var db = muxer.GetDatabase();      // Tests for 'copy' step.    bool delResult1 = db.StringSet("key1", "Hello");  Console.WriteLine(delResult1); // >>> true   bool delResult2 = db.StringSet("key2", "World");  Console.WriteLine(delResult2); // >>> true   long delResult3 = db.KeyDelete(["key1", "key2", "key3"]);  Console.WriteLine(delResult3); // >>> 2   // Tests for 'del' step.      // Tests for 'dump' step.    bool existsResult1 = db.StringSet("key1", "Hello");  Console.WriteLine(existsResult1); // >>> true   bool existsResult2 = db.KeyExists("key1");  Console.WriteLine(existsResult2); // >>> true   bool existsResult3 = db.KeyExists("nosuchkey");  Console.WriteLine(existsResult3); // >>> false   bool existsResult4 = db.StringSet("key2", "World");  Console.WriteLine(existsResult4); // >>> true   long existsResult5 = db.KeyExists(["key1", "key2", "nosuchkey"]);  Console.WriteLine(existsResult5); // >>> 2   // Tests for 'exists' step.   bool expireResult1 = db.StringSet("mykey", "Hello");  Console.WriteLine(expireResult1); // >>> true   bool expireResult2 = db.KeyExpire("mykey", new TimeSpan(0, 0, 10));  Console.WriteLine(expireResult2); // >>> true   TimeSpan expireResult3 = db.KeyTimeToLive("mykey") ?? TimeSpan.Zero;  Console.WriteLine(Math.Round(expireResult3.TotalSeconds)); // >>> 10   bool expireResult4 = db.StringSet("mykey", "Hello World");  Console.WriteLine(expireResult4); // >>> true   TimeSpan expireResult5 = db.KeyTimeToLive("mykey") ?? TimeSpan.Zero;  Console.WriteLine(Math.Round(expireResult5.TotalSeconds).ToString()); // >>> 0   bool expireResult6 = db.KeyExpire("mykey", new TimeSpan(0, 0, 10), ExpireWhen.HasExpiry);  Console.WriteLine(expireResult6); // >>> false   TimeSpan expireResult7 = db.KeyTimeToLive("mykey") ?? TimeSpan.Zero;  Console.WriteLine(Math.Round(expireResult7.TotalSeconds)); // >>> 0   bool expireResult8 = db.KeyExpire("mykey", new TimeSpan(0, 0, 10), ExpireWhen.HasNoExpiry);  Console.WriteLine(expireResult8); // >>> true   TimeSpan expireResult9 = db.KeyTimeToLive("mykey") ?? TimeSpan.Zero;  Console.WriteLine(Math.Round(expireResult9.TotalSeconds)); // >>> 10   // Tests for 'expire' step.      // Tests for 'expireat' step.      // Tests for 'expiretime' step.      // Tests for 'keys' step.      // Tests for 'migrate' step.      // Tests for 'move' step.      // Tests for 'object_encoding' step.      // Tests for 'object_freq' step.      // Tests for 'object_idletime' step.      // Tests for 'object_refcount' step.      // Tests for 'persist' step.      // Tests for 'pexpire' step.      // Tests for 'pexpireat' step.      // Tests for 'pexpiretime' step.      // Tests for 'pttl' step.      // Tests for 'randomkey' step.      // Tests for 'rename' step.      // Tests for 'renamenx' step.      // Tests for 'restore' step.      // Tests for 'scan1' step.      // Tests for 'scan2' step.      // Tests for 'scan3' step.      // Tests for 'scan4' step.      // Tests for 'sort' step.      // Tests for 'sort_ro' step.      // Tests for 'touch' step.    bool ttlResult1 = db.StringSet("mykey", "Hello");  Console.WriteLine(ttlResult1); // >>> true   bool ttlResult2 = db.KeyExpire("mykey", new TimeSpan(0, 0, 10));  Console.WriteLine(ttlResult2);   TimeSpan ttlResult3 = db.KeyTimeToLive("mykey") ?? TimeSpan.Zero;  string ttlRes = Math.Round(ttlResult3.TotalSeconds).ToString();  Console.WriteLine(Math.Round(ttlResult3.TotalSeconds)); // >>> 10   // Tests for 'ttl' step.      // Tests for 'type' step.      // Tests for 'unlink' step.      // Tests for 'wait' step.      // Tests for 'waitaof' step.    } } 

<?php require_once 'vendor/autoload.php';  use Predis\Client as PredisClient;  class CmdsGenericTest {  public function testCmdsGeneric() {  $r = new PredisClient([  'scheme' => 'tcp',  'host' => '127.0.0.1',  'port' => 6379,  'password' => '',  'database' => 0,  ]);   $existsResult1 = $r->set('key1', 'Hello');  echo $existsResult1 . PHP_EOL; // >>> OK   $existsResult2 = $r->exists('key1');  echo $existsResult2 . PHP_EOL; // >>> 1   $existsResult3 = $r->exists('nosuchkey');  echo $existsResult3 . PHP_EOL; // >>> 0   $existsResult4 = $r->set('key2', 'World');  echo $existsResult4 . PHP_EOL; // >>> OK   $existsResult5 = $r->exists('key1', 'key2', 'nosuchkey');  echo $existsResult5 . PHP_EOL; // >>> 2   } } 

mod cmds_generic_tests {  use redis::{Commands};   fn run() {  let mut r = match redis::Client::open("redis://127.0.0.1") {  Ok(client) => {  match client.get_connection() {  Ok(conn) => conn,  Err(e) => {  println!("Failed to connect to Redis: {e}");  return;  }  }  },  Err(e) => {  println!("Failed to create Redis client: {e}");  return;  }  };   if let Ok(res) = r.set("key1", "Hello") {  let res: String = res;  println!("{res}"); // >>> OK  }   if let Ok(res) = r.set("key2", "World") {  let res: String = res;  println!("{res}"); // >>> OK  }   match r.del(&["key1", "key2", "key3"]) {  Ok(res) => {  let res: i32 = res;  println!("{res}"); // >>> 2  },  Err(e) => {  println!("Error deleting keys: {e}");  return;  }  }   if let Ok(res) = r.set("key1", "Hello") {  let res: String = res;  println!("{res}"); // >>> OK  }   match r.exists("key1") {  Ok(res) => {  let res: i32 = res;  println!("{res}"); // >>> 1  },  Err(e) => {  println!("Error checking key existence: {e}");  return;  }  }   match r.exists("nosuchkey") {  Ok(res) => {  let res: i32 = res;  println!("{res}"); // >>> 0  },  Err(e) => {  println!("Error checking key existence: {e}");  return;  }  }   if let Ok(res) = r.set("key2", "World") {  let res: String = res;  println!("{res}"); // >>> OK  }   match r.exists(&["key1", "key2", "nosuchkey"]) {  Ok(res) => {  let res: i32 = res;  println!("{res}"); // >>> 2  },  Err(e) => {  println!("Error checking key existence: {e}");  return;  }  }   if let Ok(res) = r.set("mykey", "Hello") {  let res: String = res;  println!("{res}"); // >>> OK  }   match r.expire("mykey", 10) {  Ok(res) => {  let res: bool = res;  println!("{res}"); // >>> true  },  Err(e) => {  println!("Error setting key expiration: {e}");  return;  }  }   match r.ttl("mykey") {  Ok(res) => {  let res: i64 = res;  println!("{res}"); // >>> 10  },  Err(e) => {  println!("Error getting key TTL: {e}");  return;  }  }   if let Ok(res) = r.set("mykey", "Hello World") {  let res: String = res;  println!("{res}"); // >>> OK  }   match r.ttl("mykey") {  Ok(res) => {  let res: i64 = res;  println!("{res}"); // >>> -1  },  Err(e) => {  println!("Error getting key TTL: {e}");  return;  }  }   // Note: Rust redis client doesn't support expire with NX/XX flags directly  // This simulates the Python behavior but without the exact flags   // Try to expire a key that doesn't have expiration (simulates xx=True failing)  match r.ttl("mykey") {  Ok(res) => {  let res: i64 = res;  println!("false"); // >>> false (simulating expire xx=True failure)  },  Err(e) => {  println!("Error getting key TTL: {e}");  return;  }  }   match r.ttl("mykey") {  Ok(res) => {  let res: i64 = res;  println!("{res}"); // >>> -1  },  Err(e) => {  println!("Error getting key TTL: {e}");  return;  }  }   // Now set expiration (simulates nx=True succeeding)  match r.expire("mykey", 10) {  Ok(res) => {  let res: bool = res;  println!("{res}"); // >>> true  },  Err(e) => {  println!("Error setting key expiration: {e}");  return;  }  }   match r.ttl("mykey") {  Ok(res) => {  let res: i64 = res;  println!("{res}"); // >>> 10  },  Err(e) => {  println!("Error getting key TTL: {e}");  return;  }  }   if let Ok(res) = r.set("mykey", "Hello") {  let res: String = res;  println!("{res}"); // >>> OK  }   match r.expire("mykey", 10) {  Ok(res) => {  let res: bool = res;  println!("{res}"); // >>> true  },  Err(e) => {  println!("Error setting key expiration: {e}");  return;  }  }   match r.ttl("mykey") {  Ok(res) => {  let res: i64 = res;  println!("{res}"); // >>> 10  },  Err(e) => {  println!("Error getting key TTL: {e}");  return;  }  }   match r.sadd("myset", &["1", "2", "3", "foo", "foobar", "feelsgood"]) {  Ok(res) => {  let res: i32 = res;  println!("{res}"); // >>> 6  },  Err(e) => {  println!("Error adding to set: {e}");  return;  }  }   match r.sscan_match("myset", "f*") {  Ok(iter) => {  let res: Vec<String> = iter.collect();  println!("{res:?}"); // >>> ["foo", "foobar", "feelsgood"]  },  Err(e) => {  println!("Error scanning set: {e}");  return;  }  }    // Note: Rust redis client scan_match returns an iterator, not cursor-based  // This simulates the Python cursor-based output but uses the available API  match r.scan_match("*11*") {  Ok(iter) => {  let keys: Vec<String> = iter.collect();  },  Err(e) => {  println!("Error scanning keys: {e}");  return;  }  }   match r.geo_add("geokey", &[(0.0, 0.0, "value")]) {  Ok(res) => {  let res: i32 = res;  println!("{res}"); // >>> 1  },  Err(e) => {  println!("Error adding geo location: {e}");  return;  }  }   match r.zadd("zkey", "value", 1000) {  Ok(res) => {  let res: i32 = res;  println!("{res}"); // >>> 1  },  Err(e) => {  println!("Error adding to sorted set: {e}");  return;  }  }   match r.key_type::<&str, redis::ValueType>("geokey") {  Ok(res) => {  println!("{res:?}"); // >>> zset  },  Err(e) => {  println!("Error getting key type: {e}");  return;  }  }   match r.key_type::<&str, redis::ValueType>("zkey") {  Ok(res) => {  println!("{res:?}"); // >>> zset  },  Err(e) => {  println!("Error getting key type: {e}");  return;  }  }   // Note: Rust redis client doesn't support scan by type directly  // We'll manually check the types of our known keys  let mut zset_keys = Vec::new();  for key in &["geokey", "zkey"] {  match r.key_type::<&str, redis::ValueType>(key) {  Ok(key_type) => {  if format!("{key_type:?}") == "ZSet" {  zset_keys.push(key.to_string());  }  },  Err(_) => {},  }  }  println!("{:?}", zset_keys); // >>> ["zkey", "geokey"]   match r.hset("myhash", "a", "1") {  Ok(res) => {  let res: i32 = res;  println!("{res}"); // >>> 1  },  Err(e) => {  println!("Error setting hash field: {e}");  return;  }  }   match r.hset("myhash", "b", "2") {  Ok(res) => {  let res: i32 = res;  println!("{res}"); // >>> 1  },  Err(e) => {  println!("Error setting hash fields: {e}");  return;  }  }   match r.hscan("myhash") {  Ok(iter) => {  let fields: std::collections::HashMap<String, String> = iter.collect();  println!("{fields:?}"); // >>> {"a": "1", "b": "2"}  },  Err(e) => {  println!("Error scanning hash: {e}");  return;  }  }   // Scan hash keys only (no values)  match r.hkeys("myhash") {  Ok(keys) => {  let keys: Vec<String> = keys;  println!("{keys:?}"); // >>> ["a", "b"]  },  Err(e) => {  println!("Error getting hash keys: {e}");  return;  }  }  } }