🥮 mooncakes.io

    redis

    Async Redis client for MoonBit, built on `moonbitlang/async`.

    Download zip
    Author
    Version
    0.1.1
    License
    Apache-2.0
    Repository
    Last updated
    4 months ago
    Downloads
    43

    Dependencies

    #hackwaly/redis

    Async Redis client for MoonBit, built on moonbitlang/async.

    The client supports common Redis commands, typed response decoding, transactions, automatic pipelining from concurrent calls, raw commands, and RESP2 pub/sub.

    #Features

    • Async Redis client built on moonbitlang/async
    • RESP3 command connections with RESP2 fallback
    • Typed helpers for strings, keys, hashes, lists, sets, and sorted sets
    • Automatic pipelining for concurrent commands on the same Client
    • Transactions with WATCH, MULTI, and EXEC
    • Raw commands through Command
    • Pub/sub with typed channel and pattern messages
    • Configurable authentication, database selection, timeouts, reconnect strategy, and command queue bounds
    • Typed client errors for server, transport, protocol, decoding, overflow, and worker-state failures

    #Installation

    Add the package to your MoonBit project:

    moon add hackwaly/redis

    Then import it from your package's moon.pkg:

    import {
      "hackwaly/redis"
    }

    #Quick Start

    Regular commands run through a background worker. Start client.work() in a task group, issue commands on the same Client, and cancel the worker when the client is no longer needed.

    ///|
    pub async fn quick_start() -> Unit {
      @async.with_task_group(group => {
        let client = @redis.Client(
          config=@redis.ClientConfig(host="127.0.0.1", port=6379),
        )
        let worker = group.spawn(() => client.work(), allow_failure=true)
        defer worker.cancel()

        assert_true(client.ping() == "PONG")
        assert_true(client.set("moonbit:redis:hello", "world"))
        assert_true(client.get("moonbit:redis:hello") is Some("world"))
      })
    }

    Command connections try RESP3 first and fall back to RESP2 when the server does not support HELLO 3.

    #Configuration

    ClientConfig controls connection, authentication, database selection, timeouts, reconnect behavior, and command queue bounds.

    ///|
    pub fn example_config() -> @redis.ClientConfig {
      @redis.ClientConfig(
        host="127.0.0.1",
        port=6379,
        username="default",
        password="secret",
        database=0,
        name="moonbit-app",
        command_queue_max_length=1024,
      )
    }

    #Commands

    The client exposes typed helpers for Redis strings, keys, hashes, lists, sets, sorted sets, scanning, and related commands.

    ///|
    pub async fn command_examples(client : @redis.Client) -> Unit {
      assert_true(client.set("counter", "1"))
      assert_true(client.incr("counter") == 2)
      assert_true(client.mget(["counter", "missing"]) is [Some("2"), None])

      assert_true(client.hset("user:1", "name", "MoonBit") == 1)
      assert_true(client.hget("user:1", "name") is Some("MoonBit"))
    }

    Use Client::execute with Command for raw commands not covered by a helper:

    ///|
    pub async fn raw_command_example(client : @redis.Client) -> String {
      client.execute(@redis.Command([b"PING"], value => value.as_string()))
    }

    #Automatic Pipelining

    Like node-redis Promise.all, this client automatically pipelines commands that are issued concurrently on the same Client. Each call is queued, the worker writes commands to the connection in order, and responses are matched back to their waiting tasks.

    ///|
    pub async fn auto_pipeline_example(
      client : @redis.Client,
    ) -> (String?, String?, Int) {
      @async.with_task_group(group => {
        let first = group.spawn(() => client.get("key:1"))
        let second = group.spawn(() => client.get("key:2"))
        let count = group.spawn(() => client.exists(["key:1", "key:2"]))

        (first.wait(), second.wait(), count.wait())
      })
    }

    There is no separate pipeline object for this behavior. Use concurrent async contexts when you want multiple independent commands to share one connection round trip pattern.

    #Transactions

    Transactions use Client::transaction, Transaction::watch, Multi, and MultiResult::get.

    ///|
    pub async fn transaction_example(client : @redis.Client) -> Unit {
      client.transaction(tx => {
        tx.watch(["account:1"])

        let multi = @redis.Multi()
        let old_value = multi.get("account:1")
        let wrote = multi.set("account:1", "updated")

        guard tx.exec(multi) is Some(result) else {
          fail("transaction was aborted")
        }
        ignore(result.get(old_value))
        assert_true(result.get(wrote))
      })
    }

    If watched keys are modified before EXEC, tx.exec(multi) returns None. Errors for individual queued commands are raised when reading that token with MultiResult::get.

    #Pub/Sub

    Pub/sub callbacks receive typed channel or pattern messages. Run subscriptions in their own async task and cancel that task when you want to stop receiving messages.

    ///|
    pub async fn pubsub_example() -> Unit {
      @async.with_task_group(group => {
        let publisher = @redis.Client(
          config=@redis.ClientConfig(host="127.0.0.1", port=6379),
        )
        let publisher_worker = group.spawn(
          () => publisher.work(),
          allow_failure=true,
        )
        defer publisher_worker.cancel()

        let subscriber = @redis.Client(
          config=@redis.ClientConfig(host="127.0.0.1", port=6379),
        )
        let received = group.spawn(
          () => {
            subscriber.subscribe("events", msg => {
              assert_true(msg.channel == "events")
              assert_true(msg.payload.text() == "hello")
            })
          },
          allow_failure=true,
        )

        ignore(publisher.publish("events", "hello"))
        received.cancel()
      })
    }

    subscribe and psubscribe are long-running operations. Cancel the task that runs the subscription when you want to stop receiving messages.

    #Error Handling

    Redis server errors are raised as ServerError. Protocol shape mismatches, invalid UTF-8, integer overflow, transport failures, handshake failures, and concurrent worker misuse are reported with ClientError variants:

    ///|
    pub async fn handle_error(client : @redis.Client) -> Unit {
      try client.get("key") catch {
        @redis.ServerError(message) => println("Redis error: \{message}")
        _ => println("Client error")
      } noraise {
        _ => ()
      }
    }

    #Roadmap

    The roadmap is non-binding and describes possible future work:

    • Pub/sub over RESP3 push messages multiplexed on the main client connection
    • Connection pooling for workloads that need multiple independent Redis connections
    • Broader command coverage, especially Redis Streams and scripting helpers
    • More pub/sub ergonomics around cancellation and subscription lifecycle
    • Improved README and API examples as MoonBit package documentation evolves
    • Possible Redis Cluster or Sentinel support later

    #Testing

    Run unit tests:

    moon test

    Run Redis integration tests with Docker:

    ./scripts/redis-integration-test.sh

    The integration script starts redis:7-alpine on 127.0.0.1:6380 and runs the integration package against it.

    #License

    Apache-2.0

    ClientError

    source
    pub suberror ClientError {
      ServerError(String)
      TransportError(Error)
      HandshakeError(String)
      UnexpectedResponse(String)
      InvalidUtf8(Bytes)
      IntegerOverflow(Int64)
      ClientAlreadyWorking
    }

    Errors raised by this Redis client.

    Server-side Redis errors are reported as ServerError. Other variants cover connection setup, transport, response decoding, and client lifecycle misuse.

    Example:
    try client.get("key") catch {
      @redis.ServerError(message) => println(message)
      @redis.ClientAlreadyWorking => println("client is already running")
      _ => println("redis client error")
    } noraise {
      _ => ()
    }

    Client

    source
    pub struct Client {
      // private fields
    }
    fn Client::Client(config? : ClientConfig) -> Client

    Redis client.

    Create one with Client::Client, run Client::work in a background async task, then call command methods such as get, set, or publish from other tasks.

    Example:
    @async.with_task_group(group => {
      let client = @redis.Client()
      let worker = group.spawn(() => client.work(), allow_failure=true)
      defer worker.cancel()

      ignore(client.ping())
    })

    Client::append

    source
    async fn Client::append(self : Client, key : String, value : String) -> Int

    Client::decr

    source
    async fn Client::decr(self : Client, key : String) -> Int

    Client::decrby

    source
    async fn Client::decrby(self : Client, key : String, decrement : Int) -> Int

    Client::del

    source
    async fn Client::del(self : Client, keys : ArrayView[String]) -> Int

    Client::echo

    source
    async fn Client::echo(self : Client, message : String) -> String

    Client::execute

    source
    async fn[T] Client::execute(self : Client, cmd : Command[T]) -> T

    Runs a custom Redis command through this client.

    Use this when the package does not provide a typed helper for the command you need. The command's decoder decides the result type and may raise if the Redis response has an unexpected shape.

    Example:
    let pong = client.execute(@redis.Command([b"PING"], value => value.as_string()))

    Client::exists

    source
    async fn Client::exists(self : Client, keys : ArrayView[String]) -> Int

    Client::expire

    source
    async fn Client::expire(self : Client, key : String, seconds : Int) -> Bool

    Client::get

    source
    async fn Client::get(self : Client, key : String) -> String?

    Reads a string value. Returns None when the key does not exist.

    Example:
    assert_true(client.get("missing") is None)

    Client::getrange

    source
    async fn Client::getrange(self : Client, key : String, start : Int, end : Int) -> String

    Client::hdel

    source
    async fn Client::hdel(self : Client, key : String, fields : ArrayView[String]) -> Int

    Client::hexists

    source
    async fn Client::hexists(self : Client, key : String, field : String) -> Bool

    Client::hget

    source
    async fn Client::hget(self : Client, key : String, field : String) -> String?

    Reads a hash field. Returns None when the key or field does not exist.

    Example:
    assert_true(client.hget("user:1", "name") is Some("MoonBit"))

    Client::hgetall

    source
    async fn Client::hgetall(self : Client, key : String) -> Map[String, String]

    Reads all fields from a hash as a map.

    Example:
    let fields = client.hgetall("user:1")

    Client::hincrby

    source
    async fn Client::hincrby(self : Client, key : String, field : String, increment : Int) -> Int

    Client::hincrbyfloat

    source
    async fn Client::hincrbyfloat(self : Client, key : String, field : String, increment : Double) -> Double

    Client::hkeys

    source
    async fn Client::hkeys(self : Client, key : String) -> Array[String]

    Client::hlen

    source
    async fn Client::hlen(self : Client, key : String) -> Int

    Client::hmget

    source
    async fn Client::hmget(self : Client, key : String, fields : ArrayView[String]) -> Array[String?]

    Client::hmset

    source
    async fn Client::hmset(self : Client, key : String, fields : ArrayView[(String, String)]) -> Unit

    Client::hscan

    source
    async fn Client::hscan(self : Client, key : String, cursor : String, pattern? : String, count? : Int) -> (String, Map[String, String])

    Client::hset

    source
    async fn Client::hset(self : Client, key : String, field : String, value : String) -> Int

    Sets a hash field and returns the number of fields newly added.

    Example:
    ignore(client.hset("user:1", "name", "MoonBit"))

    Client::hstrlen

    source
    async fn Client::hstrlen(self : Client, key : String, field : String) -> Int

    Client::hvals

    source
    async fn Client::hvals(self : Client, key : String) -> Array[String]

    Client::incr

    source
    async fn Client::incr(self : Client, key : String) -> Int

    Increments an integer string value by one and returns the new value.

    Example:
    ignore(client.set("count", "1"))
    assert_true(client.incr("count") == 2)

    Client::incrby

    source
    async fn Client::incrby(self : Client, key : String, increment : Int) -> Int

    Client::incrbyfloat

    source
    async fn Client::incrbyfloat(self : Client, key : String, increment : Double) -> Double

    Client::keys

    source
    async fn Client::keys(self : Client, pattern : String) -> Array[String]

    Client::lindex

    source
    async fn Client::lindex(self : Client, key : String, index : Int) -> String?

    Client::linsert_after

    source
    async fn Client::linsert_after(self : Client, key : String, pivot : String, value : String) -> Int

    Client::linsert_before

    source
    async fn Client::linsert_before(self : Client, key : String, pivot : String, value : String) -> Int

    Client::llen

    source
    async fn Client::llen(self : Client, key : String) -> Int

    Client::lpop

    source
    async fn Client::lpop(self : Client, key : String) -> String?

    Client::lpop_count

    source
    async fn Client::lpop_count(self : Client, key : String, count : Int) -> Array[String]

    Client::lpush

    source
    async fn Client::lpush(self : Client, key : String, values : ArrayView[String]) -> Int

    Pushes values to the left side of a list and returns the new list length.

    Example:
    ignore(client.lpush("jobs", ["a", "b"]))

    Client::lrange

    source
    async fn Client::lrange(self : Client, key : String, start : Int, stop : Int) -> Array[String]

    Reads a range from a list.

    Example:
    let values = client.lrange("jobs", 0, -1)

    Client::lrem

    source
    async fn Client::lrem(self : Client, key : String, count : Int, value : String) -> Int

    Client::lset

    source
    async fn Client::lset(self : Client, key : String, index : Int, value : String) -> Unit

    Client::ltrim

    source
    async fn Client::ltrim(self : Client, key : String, start : Int, stop : Int) -> Unit

    Client::mget

    source
    async fn Client::mget(self : Client, keys : ArrayView[String]) -> Array[String?]

    Reads multiple string values in the same order as keys.

    Missing keys are returned as None.

    Example:
    let values = client.mget(["name", "missing"])
    assert_true(values is [Some("MoonBit"), None])

    Client::mset

    source
    async fn Client::mset(self : Client, items : ArrayView[(String, String)]) -> Unit

    Client::msetnx

    source
    async fn Client::msetnx(self : Client, items : ArrayView[(String, String)]) -> Bool

    Client::persist

    source
    async fn Client::persist(self : Client, key : String) -> Bool

    Client::pexpire

    source
    async fn Client::pexpire(self : Client, key : String, milliseconds : Int) -> Bool

    Client::ping

    source
    async fn Client::ping(self : Client, message? : String) -> String

    Checks that Redis is reachable.

    Example:
    assert_true(client.ping() == "PONG")
    assert_true(client.ping(message="hello") == "hello")

    Client::psetex

    source
    async fn Client::psetex(self : Client, key : String, milliseconds : Int, value : String) -> Unit

    Client::psubscribe

    source
    async fn Client::psubscribe(self : Client, pattern : String, callback : async (PatternMessage) -> Unit) -> Unit

    Pattern-subscribes and invokes callback for each matching message.

    This is a long-running operation. Run it in its own async task and cancel that task to stop receiving messages.

    Example:
    group.spawn(() => {
      client.psubscribe("events:*", msg => {
        println(msg.channel)
      })
    }, allow_failure=true)

    Client::pttl

    source
    async fn Client::pttl(self : Client, key : String) -> Int

    Client::publish

    source
    async fn Client::publish(self : Client, channel : String, payload : &
    Data    ) -> Int

    Publishes payload to channel and returns the number of subscribers that received the message.

    Example:
    let receivers = client.publish("events", "hello")

    Client::randomkey

    source
    async fn Client::randomkey(self : Client) -> String?

    Client::rename

    source
    async fn Client::rename(self : Client, key : String, new_key : String) -> Unit

    Client::renamenx

    source
    async fn Client::renamenx(self : Client, key : String, new_key : String) -> Bool

    Client::rpop

    source
    async fn Client::rpop(self : Client, key : String) -> String?

    Client::rpop_count

    source
    async fn Client::rpop_count(self : Client, key : String, count : Int) -> Array[String]

    Client::rpush

    source
    async fn Client::rpush(self : Client, key : String, values : ArrayView[String]) -> Int

    Client::sadd

    source
    async fn Client::sadd(self : Client, key : String, members : ArrayView[String]) -> Int

    Adds members to a set and returns the number of members newly added.

    Example:
    ignore(client.sadd("tags", ["moonbit", "redis"]))

    Client::scan

    source
    async fn Client::scan(self : Client, cursor : String, pattern? : String, count? : Int) -> (String, Array[String])

    Client::scard

    source
    async fn Client::scard(self : Client, key : String) -> Int

    Client::sdiff

    source
    async fn Client::sdiff(self : Client, keys : ArrayView[String]) -> 
    HashSet    [String]

    Client::sdiffstore

    source
    async fn Client::sdiffstore(self : Client, destination : String, keys : ArrayView[String]) -> Int

    Client::set

    source
    async fn Client::set(self : Client, key : String, value : String, ex? : Int, px? : Int, nx? : Bool, xx? : Bool) -> Bool

    Sets a string value.

    Returns false when nx or xx prevents the write.

    Example:
    assert_true(client.set("name", "MoonBit"))
    assert_true(client.set("token", "abc", ex=60, nx=true))

    Client::set_get

    source
    async fn Client::set_get(self : Client, key : String, value : String, ex? : Int, px? : Int, nx? : Bool, xx? : Bool) -> String?

    Client::setex

    source
    async fn Client::setex(self : Client, key : String, seconds : Int, value : String) -> Unit

    Client::setnx

    source
    async fn Client::setnx(self : Client, key : String, value : String) -> Bool

    Client::setrange

    source
    async fn Client::setrange(self : Client, key : String, offset : Int, value : String) -> Int

    Client::sinter

    source
    async fn Client::sinter(self : Client, keys : ArrayView[String]) -> 
    HashSet    [String]

    Client::sinterstore

    source
    async fn Client::sinterstore(self : Client, destination : String, keys : ArrayView[String]) -> Int

    Client::sismember

    source
    async fn Client::sismember(self : Client, key : String, value : String) -> Bool

    Client::smembers

    source
    async fn Client::smembers(self : Client, key : String) -> 
    HashSet    [String]

    Reads all members of a set.

    Example:
    let members = client.smembers("tags")

    Client::smismember

    source
    async fn Client::smismember(self : Client, key : String, members : ArrayView[String]) -> Array[Bool]

    Client::smove

    source
    async fn Client::smove(self : Client, source : String, destination : String, value : String) -> Bool

    Client::spop

    source
    async fn Client::spop(self : Client, key : String) -> String?

    Client::spop_count

    source
    async fn Client::spop_count(self : Client, key : String, count : Int) -> 
    HashSet    [String]

    Client::srandmember

    source
    async fn Client::srandmember(self : Client, key : String) -> String?

    Client::srandmember_count

    source
    async fn Client::srandmember_count(self : Client, key : String, count : Int) -> Array[String]

    Client::srem

    source
    async fn Client::srem(self : Client, key : String, members : ArrayView[String]) -> Int

    Client::sscan

    source
    async fn Client::sscan(self : Client, key : String, cursor : String, pattern? : String, count? : Int) -> (String, 
    HashSet    [String])

    Client::strlen

    source
    async fn Client::strlen(self : Client, key : String) -> Int

    Client::subscribe

    source
    async fn Client::subscribe(self : Client, channel : String, callback : async (Message) -> Unit) -> Unit

    Subscribes to one channel and invokes callback for each received message.

    This is a long-running operation. Run it in its own async task and cancel that task to stop receiving messages.

    Example:
    group.spawn(() => {
      client.subscribe("events", msg => {
        println(msg.payload.text())
      })
    }, allow_failure=true)

    Client::sunion

    source
    async fn Client::sunion(self : Client, keys : ArrayView[String]) -> 
    HashSet    [String]

    Client::sunionstore

    source
    async fn Client::sunionstore(self : Client, destination : String, keys : ArrayView[String]) -> Int

    Client::transaction

    source
    async fn[T] Client::transaction(self : Client, f : async (Transaction) -> T) -> T

    Runs a callback in a Redis transaction session.

    Use Transaction::watch before building a Multi when optimistic locking is needed. The returned value is whatever the callback returns.

    Example:
    client.transaction(tx => {
      tx.watch(["account:1"])
      let multi = @redis.Multi()
      let wrote = multi.set("account:1", "updated")

      guard tx.exec(multi) is Some(result) else {
        fail("transaction aborted")
      }
      result.get(wrote)
    })

    Client::ttl

    source
    async fn Client::ttl(self : Client, key : String) -> Int

    Client::type_

    source
    async fn Client::type_(self : Client, key : String) -> String

    Client::work

    source
    async fn Client::work(self : Client) -> Unit

    Keeps the regular command connection running.

    A client may have at most one active work loop. Start a new Client if you need another independent Redis connection. Cancelling the task running work is the normal way to stop the client.

    Example:
    @async.with_task_group(group => {
      let client = @redis.Client()
      let worker = group.spawn(() => client.work(), allow_failure=true)
      defer worker.cancel()

      assert_true(client.set("hello", "world"))
    })

    Client::zadd

    source
    async fn Client::zadd(self : Client, key : String, items : ArrayView[(String, Double)]) -> Int

    Adds members with scores to a sorted set.

    Example:
    ignore(client.zadd("rank", [("alice", 10.0), ("bob", 8.0)]))

    Client::zcard

    source
    async fn Client::zcard(self : Client, key : String) -> Int

    Client::zcount

    source
    async fn Client::zcount(self : Client, key : String, min : Double, max : Double) -> Int

    Client::zincrby

    source
    async fn Client::zincrby(self : Client, key : String, increment : Double, value : String) -> Double

    Client::zpopmax

    source
    async fn Client::zpopmax(self : Client, key : String, count? : Int) -> Array[(String, Double)]

    Client::zpopmin

    source
    async fn Client::zpopmin(self : Client, key : String, count? : Int) -> Array[(String, Double)]

    Client::zrange

    source
    async fn Client::zrange(self : Client, key : String, start : Int, stop : Int) -> Array[String]

    Reads sorted set members by rank.

    Example:
    let top = client.zrange("rank", 0, 9)

    Client::zrange_with_scores

    source
    async fn Client::zrange_with_scores(self : Client, key : String, start : Int, stop : Int) -> Array[(String, Double)]

    Client::zrangebyscore

    source
    async fn Client::zrangebyscore(self : Client, key : String, min : Double, max : Double, offset? : Int, count? : Int) -> Array[String]

    Client::zrangebyscore_with_scores

    source
    async fn Client::zrangebyscore_with_scores(self : Client, key : String, min : Double, max : Double, offset? : Int, count? : Int) -> Array[(String, Double)]

    Client::zrank

    source
    async fn Client::zrank(self : Client, key : String, value : String) -> Int?

    Client::zrem

    source
    async fn Client::zrem(self : Client, key : String, members : ArrayView[String]) -> Int

    Client::zremrangebyrank

    source
    async fn Client::zremrangebyrank(self : Client, key : String, start : Int, stop : Int) -> Int

    Client::zremrangebyscore

    source
    async fn Client::zremrangebyscore(self : Client, key : String, min : Double, max : Double) -> Int

    Client::zrevrange

    source
    async fn Client::zrevrange(self : Client, key : String, start : Int, stop : Int) -> Array[String]

    Client::zrevrange_with_scores

    source
    async fn Client::zrevrange_with_scores(self : Client, key : String, start : Int, stop : Int) -> Array[(String, Double)]

    Client::zrevrank

    source
    async fn Client::zrevrank(self : Client, key : String, value : String) -> Int?

    Client::zscan

    source
    async fn Client::zscan(self : Client, key : String, cursor : String, pattern? : String, count? : Int) -> (String, Array[(String, Double)])

    Client::zscore

    source
    async fn Client::zscore(self : Client, key : String, value : String) -> Double?

    ClientConfig

    source
    pub struct ClientConfig {
      name : String?
      host : String
      port : Int
      username : String
      password : String?
      database : Int
      read_buffer_size : Int
      write_buffer_size : Int
      resp_max_depth : Int
      connect_timeout : Double
      reconnect_strategy : 
    RetryMethod
      command_queue_max_length : Int?
    }
    fn ClientConfig::ClientConfig(name? : String, host? : String, port? : Int, username? : String, password? : String, database? : Int, read_buffer_size? : Int, write_buffer_size? : Int, resp_max_depth? : Int, connect_timeout? : Double, reconnect_strategy? : 
    RetryMethod    , command_queue_max_length? : Int) -> ClientConfig

    Connection and runtime options for Client.

    The default configuration connects to 127.0.0.1:6379, authenticates as the Redis default user when a password is provided, uses database 0, and retries reconnects with exponential backoff.

    Example:
    let config = @redis.ClientConfig(host="127.0.0.1", port=6379, password="secret")

    let client = @redis.Client(config~)

    Command

    source
    pub struct Command[T] {
      // private fields
    }
    fn Command::Command(args : Array[Bytes], res_decode_fn : (RawValue) -> T raise) -> Command[T]

    Custom Redis command with a typed result.

    Use Command with Client::execute for commands that do not yet have a typed helper. Pass command parts in Redis order, starting with the command name, and provide a decoder for the response.

    Example:
    let info = client.execute(
      @redis.Command([b"INFO", b"server"], value => value.as_string()),
    )

    Message

    source
    pub struct Message {
      channel : String
      payload : &
    Data
    }

    Message delivered by Client::subscribe.

    Example:
    msg.channel
    msg.payload.text()

    Multi

    source
    pub struct Multi {
      // private fields
    }
    fn Multi::Multi() -> Multi

    Builder for commands that should run inside one Redis transaction.

    Add commands to a Multi, keep the returned tokens, then pass the Multi to Transaction::exec and read each result with MultiResult::get.

    Example:
    let multi = @redis.Multi()

    let old_value = multi.get("account:1")

    let wrote = multi.set("account:1", "updated")

    Multi::append

    source
    fn Multi::append(self : Multi, key : String, value : String) -> MultiToken[Int]

    Multi::decr

    source
    fn Multi::decr(self : Multi, key : String) -> MultiToken[Int]

    Multi::decrby

    source
    fn Multi::decrby(self : Multi, key : String, decrement : Int) -> MultiToken[Int]

    Multi::del

    source
    fn Multi::del(self : Multi, keys : ArrayView[String]) -> MultiToken[Int]

    Multi::echo

    source
    fn Multi::echo(self : Multi, message : String) -> MultiToken[String]

    Multi::exists

    source
    fn Multi::exists(self : Multi, keys : ArrayView[String]) -> MultiToken[Int]

    Multi::expire

    source
    fn Multi::expire(self : Multi, key : String, seconds : Int) -> MultiToken[Bool]

    Multi::get

    source
    fn Multi::get(self : Multi, key : String) -> MultiToken[String?]

    Multi::getrange

    source
    fn Multi::getrange(self : Multi, key : String, start : Int, end : Int) -> MultiToken[String]

    Multi::hdel

    source
    fn Multi::hdel(self : Multi, key : String, fields : ArrayView[String]) -> MultiToken[Int]

    Multi::hexists

    source
    fn Multi::hexists(self : Multi, key : String, field : String) -> MultiToken[Bool]

    Multi::hget

    source
    fn Multi::hget(self : Multi, key : String, field : String) -> MultiToken[String?]

    Multi::hgetall

    source
    fn Multi::hgetall(self : Multi, key : String) -> MultiToken[Map[String, String]]

    Multi::hincrby

    source
    fn Multi::hincrby(self : Multi, key : String, field : String, increment : Int) -> MultiToken[Int]

    Multi::hincrbyfloat

    source
    fn Multi::hincrbyfloat(self : Multi, key : String, field : String, increment : Double) -> MultiToken[Double]

    Multi::hkeys

    source
    fn Multi::hkeys(self : Multi, key : String) -> MultiToken[Array[String]]

    Multi::hlen

    source
    fn Multi::hlen(self : Multi, key : String) -> MultiToken[Int]

    Multi::hmget

    source
    fn Multi::hmget(self : Multi, key : String, fields : ArrayView[String]) -> MultiToken[Array[String?]]

    Multi::hmset

    source
    fn Multi::hmset(self : Multi, key : String, fields : ArrayView[(String, String)]) -> MultiToken[Unit]

    Multi::hscan

    source
    fn Multi::hscan(self : Multi, key : String, cursor : String, pattern? : String, count? : Int) -> MultiToken[(String, Map[String, String])]

    Multi::hset

    source
    fn Multi::hset(self : Multi, key : String, field : String, value : String) -> MultiToken[Int]

    Multi::hstrlen

    source
    fn Multi::hstrlen(self : Multi, key : String, field : String) -> MultiToken[Int]

    Multi::hvals

    source
    fn Multi::hvals(self : Multi, key : String) -> MultiToken[Array[String]]

    Multi::incr

    source
    fn Multi::incr(self : Multi, key : String) -> MultiToken[Int]

    Multi::incrby

    source
    fn Multi::incrby(self : Multi, key : String, increment : Int) -> MultiToken[Int]

    Multi::incrbyfloat

    source
    fn Multi::incrbyfloat(self : Multi, key : String, increment : Double) -> MultiToken[Double]

    Multi::keys

    source
    fn Multi::keys(self : Multi, pattern : String) -> MultiToken[Array[String]]

    Multi::lindex

    source
    fn Multi::lindex(self : Multi, key : String, index : Int) -> MultiToken[String?]

    Multi::linsert_after

    source
    fn Multi::linsert_after(self : Multi, key : String, pivot : String, value : String) -> MultiToken[Int]

    Multi::linsert_before

    source
    fn Multi::linsert_before(self : Multi, key : String, pivot : String, value : String) -> MultiToken[Int]

    Multi::llen

    source
    fn Multi::llen(self : Multi, key : String) -> MultiToken[Int]

    Multi::lpop

    source
    fn Multi::lpop(self : Multi, key : String) -> MultiToken[String?]

    Multi::lpop_count

    source
    fn Multi::lpop_count(self : Multi, key : String, count : Int) -> MultiToken[Array[String]]

    Multi::lpush

    source
    fn Multi::lpush(self : Multi, key : String, values : ArrayView[String]) -> MultiToken[Int]

    Multi::lrange

    source
    fn Multi::lrange(self : Multi, key : String, start : Int, stop : Int) -> MultiToken[Array[String]]

    Multi::lrem

    source
    fn Multi::lrem(self : Multi, key : String, count : Int, value : String) -> MultiToken[Int]

    Multi::lset

    source
    fn Multi::lset(self : Multi, key : String, index : Int, value : String) -> MultiToken[Unit]

    Multi::ltrim

    source
    fn Multi::ltrim(self : Multi, key : String, start : Int, stop : Int) -> MultiToken[Unit]

    Multi::mget

    source
    fn Multi::mget(self : Multi, keys : ArrayView[String]) -> MultiToken[Array[String?]]

    Multi::mset

    source
    fn Multi::mset(self : Multi, items : ArrayView[(String, String)]) -> MultiToken[Unit]

    Multi::msetnx

    source
    fn Multi::msetnx(self : Multi, items : ArrayView[(String, String)]) -> MultiToken[Bool]

    Multi::persist

    source
    fn Multi::persist(self : Multi, key : String) -> MultiToken[Bool]

    Multi::pexpire

    source
    fn Multi::pexpire(self : Multi, key : String, milliseconds : Int) -> MultiToken[Bool]

    Multi::ping

    source
    fn Multi::ping(self : Multi, message? : String) -> MultiToken[String]

    Multi::psetex

    source
    fn Multi::psetex(self : Multi, key : String, milliseconds : Int, value : String) -> MultiToken[Unit]

    Multi::pttl

    source
    fn Multi::pttl(self : Multi, key : String) -> MultiToken[Int]

    Multi::randomkey

    source
    fn Multi::randomkey(self : Multi) -> MultiToken[String?]

    Multi::raw_command

    source
    fn[T] Multi::raw_command(self : Multi, args : ArrayView[BytesView], decode : (RawValue) -> T raise) -> MultiToken[T]

    Adds a custom command to this transaction builder.

    Example:
    let multi = @redis.Multi()

    let size = multi.raw_command([b"DBSIZE"], value => value.as_int())

    Multi::rename

    source
    fn Multi::rename(self : Multi, key : String, new_key : String) -> MultiToken[Unit]

    Multi::renamenx

    source
    fn Multi::renamenx(self : Multi, key : String, new_key : String) -> MultiToken[Bool]

    Multi::rpop

    source
    fn Multi::rpop(self : Multi, key : String) -> MultiToken[String?]

    Multi::rpop_count

    source
    fn Multi::rpop_count(self : Multi, key : String, count : Int) -> MultiToken[Array[String]]

    Multi::rpush

    source
    fn Multi::rpush(self : Multi, key : String, values : ArrayView[String]) -> MultiToken[Int]

    Multi::sadd

    source
    fn Multi::sadd(self : Multi, key : String, members : ArrayView[String]) -> MultiToken[Int]

    Multi::scan

    source
    fn Multi::scan(self : Multi, cursor : String, pattern? : String, count? : Int) -> MultiToken[(String, Array[String])]

    Multi::scard

    source
    fn Multi::scard(self : Multi, key : String) -> MultiToken[Int]

    Multi::sdiff

    source
    fn Multi::sdiff(self : Multi, keys : ArrayView[String]) -> MultiToken[
    HashSet    [String]]

    Multi::sdiffstore

    source
    fn Multi::sdiffstore(self : Multi, destination : String, keys : ArrayView[String]) -> MultiToken[Int]

    Multi::set

    source
    fn Multi::set(self : Multi, key : String, value : String, ex? : Int, px? : Int, nx? : Bool, xx? : Bool) -> MultiToken[Bool]

    Multi::set_get

    source
    fn Multi::set_get(self : Multi, key : String, value : String, ex? : Int, px? : Int, nx? : Bool, xx? : Bool) -> MultiToken[String?]

    Multi::setex

    source
    fn Multi::setex(self : Multi, key : String, seconds : Int, value : String) -> MultiToken[Unit]

    Multi::setnx

    source
    fn Multi::setnx(self : Multi, key : String, value : String) -> MultiToken[Bool]

    Multi::setrange

    source
    fn Multi::setrange(self : Multi, key : String, offset : Int, value : String) -> MultiToken[Int]

    Multi::sinter

    source
    fn Multi::sinter(self : Multi, keys : ArrayView[String]) -> MultiToken[
    HashSet    [String]]

    Multi::sinterstore

    source
    fn Multi::sinterstore(self : Multi, destination : String, keys : ArrayView[String]) -> MultiToken[Int]

    Multi::sismember

    source
    fn Multi::sismember(self : Multi, key : String, value : String) -> MultiToken[Bool]

    Multi::smembers

    source
    fn Multi::smembers(self : Multi, key : String) -> MultiToken[
    HashSet    [String]]

    Multi::smismember

    source
    fn Multi::smismember(self : Multi, key : String, members : ArrayView[String]) -> MultiToken[Array[Bool]]

    Multi::smove

    source
    fn Multi::smove(self : Multi, source : String, destination : String, value : String) -> MultiToken[Bool]

    Multi::spop

    source
    fn Multi::spop(self : Multi, key : String) -> MultiToken[String?]

    Multi::spop_count

    source
    fn Multi::spop_count(self : Multi, key : String, count : Int) -> MultiToken[
    HashSet    [String]]

    Multi::srandmember

    source
    fn Multi::srandmember(self : Multi, key : String) -> MultiToken[String?]

    Multi::srandmember_count

    source
    fn Multi::srandmember_count(self : Multi, key : String, count : Int) -> MultiToken[Array[String]]

    Multi::srem

    source
    fn Multi::srem(self : Multi, key : String, members : ArrayView[String]) -> MultiToken[Int]

    Multi::sscan

    source
    fn Multi::sscan(self : Multi, key : String, cursor : String, pattern? : String, count? : Int) -> MultiToken[(String, 
    HashSet    [String])]

    Multi::strlen

    source
    fn Multi::strlen(self : Multi, key : String) -> MultiToken[Int]

    Multi::sunion

    source
    fn Multi::sunion(self : Multi, keys : ArrayView[String]) -> MultiToken[
    HashSet    [String]]

    Multi::sunionstore

    source
    fn Multi::sunionstore(self : Multi, destination : String, keys : ArrayView[String]) -> MultiToken[Int]

    Multi::ttl

    source
    fn Multi::ttl(self : Multi, key : String) -> MultiToken[Int]

    Multi::type_

    source
    fn Multi::type_(self : Multi, key : String) -> MultiToken[String]

    Multi::zadd

    source
    fn Multi::zadd(self : Multi, key : String, items : ArrayView[(String, Double)]) -> MultiToken[Int]

    Multi::zcard

    source
    fn Multi::zcard(self : Multi, key : String) -> MultiToken[Int]

    Multi::zcount

    source
    fn Multi::zcount(self : Multi, key : String, min : Double, max : Double) -> MultiToken[Int]

    Multi::zincrby

    source
    fn Multi::zincrby(self : Multi, key : String, increment : Double, value : String) -> MultiToken[Double]

    Multi::zpopmax

    source
    fn Multi::zpopmax(self : Multi, key : String, count? : Int) -> MultiToken[Array[(String, Double)]]

    Multi::zpopmin

    source
    fn Multi::zpopmin(self : Multi, key : String, count? : Int) -> MultiToken[Array[(String, Double)]]

    Multi::zrange

    source
    fn Multi::zrange(self : Multi, key : String, start : Int, stop : Int) -> MultiToken[Array[String]]

    Multi::zrange_with_scores

    source
    fn Multi::zrange_with_scores(self : Multi, key : String, start : Int, stop : Int) -> MultiToken[Array[(String, Double)]]

    Multi::zrangebyscore

    source
    fn Multi::zrangebyscore(self : Multi, key : String, min : Double, max : Double, offset? : Int, count? : Int) -> MultiToken[Array[String]] raise

    Multi::zrangebyscore_with_scores

    source
    fn Multi::zrangebyscore_with_scores(self : Multi, key : String, min : Double, max : Double, offset? : Int, count? : Int) -> MultiToken[Array[(String, Double)]] raise

    Multi::zrank

    source
    fn Multi::zrank(self : Multi, key : String, value : String) -> MultiToken[Int?]

    Multi::zrem

    source
    fn Multi::zrem(self : Multi, key : String, members : ArrayView[String]) -> MultiToken[Int]

    Multi::zremrangebyrank

    source
    fn Multi::zremrangebyrank(self : Multi, key : String, start : Int, stop : Int) -> MultiToken[Int]

    Multi::zremrangebyscore

    source
    fn Multi::zremrangebyscore(self : Multi, key : String, min : Double, max : Double) -> MultiToken[Int]

    Multi::zrevrange

    source
    fn Multi::zrevrange(self : Multi, key : String, start : Int, stop : Int) -> MultiToken[Array[String]]

    Multi::zrevrange_with_scores

    source
    fn Multi::zrevrange_with_scores(self : Multi, key : String, start : Int, stop : Int) -> MultiToken[Array[(String, Double)]]

    Multi::zrevrank

    source
    fn Multi::zrevrank(self : Multi, key : String, value : String) -> MultiToken[Int?]

    Multi::zscan

    source
    fn Multi::zscan(self : Multi, key : String, cursor : String, pattern? : String, count? : Int) -> MultiToken[(String, Array[(String, Double)])]

    Multi::zscore

    source
    fn Multi::zscore(self : Multi, key : String, value : String) -> MultiToken[Double?]

    MultiResult

    source
    type MultiResult

    Result set returned by a successful Transaction::exec.

    MultiResult::get

    source
    fn[T] MultiResult::get(self : MultiResult, token : MultiToken[T]) -> T raise

    Reads the result for a queued command.

    Raises if Redis returned an error for that command or if the response cannot be decoded as the token's expected type.

    Example:
    let value = result.get(old_value)

    MultiToken

    source
    type MultiToken[T]

    Result handle for one command added to Multi.

    Use the token with MultiResult::get after Transaction::exec succeeds.

    PatternMessage

    source
    pub struct PatternMessage {
      pattern : String
      channel : String
      payload : &
    Data
    }

    Message delivered by Client::psubscribe.

    Example:
    msg.pattern
    msg.channel
    msg.payload.text()

    RawValue

    source
    type RawValue

    Raw Redis response passed to custom command decoders.

    Use the as_* helpers to turn a raw response into the type your custom command should return.

    Example:
    @redis.Command([b"DBSIZE"], value => value.as_int())

    RawValue::as_array

    source
    fn[T] RawValue::as_array(self : RawValue, convert : (RawValue) -> T raise) -> Array[T] raise

    Reads the response as an array by decoding each item with convert.

    RawValue::as_bool

    source
    fn RawValue::as_bool(self : RawValue) -> Bool raise

    Reads the response as Bool.

    This accepts Redis boolean replies and integer replies where 0 means false and 1 means true.

    RawValue::as_bytes

    source
    fn RawValue::as_bytes(self : RawValue) -> Bytes raise

    Reads the response as raw bytes.

    Example:
    @redis.Command([b"GET", b"blob"], value => value.as_bytes())

    RawValue::as_double

    source
    fn RawValue::as_double(self : RawValue) -> Double raise

    Reads the response as Double.

    RawValue::as_int

    source
    fn RawValue::as_int(self : RawValue) -> Int raise

    Reads the response as Int.

    Example:
    @redis.Command([b"DBSIZE"], value => value.as_int())

    RawValue::as_int64

    source
    fn RawValue::as_int64(self : RawValue) -> Int64 raise

    Reads the response as Int64.

    RawValue::as_option

    source
    fn[T] RawValue::as_option(self : RawValue, convert : (RawValue) -> T raise) -> T? raise

    Reads Redis null as None; otherwise decodes the value with convert.

    Example:
    @redis.Command([b"GET", b"name"], value => {
      value.as_option(item => item.as_string())
    })

    RawValue::as_set

    source
    fn[T : Hash + Eq] RawValue::as_set(self : RawValue, convert : (RawValue) -> T raise) -> 
    HashSet    [T] raise

    Reads the response as a HashSet by decoding each item with convert.

    RawValue::as_string

    source
    fn RawValue::as_string(self : RawValue) -> String raise

    Reads the response as a UTF-8 string.

    Example:
    @redis.Command([b"PING"], value => value.as_string())

    RawValue::as_string_map

    source
    fn RawValue::as_string_map(self : RawValue) -> Map[String, String] raise

    Reads the response as a string map.

    Example:
    @redis.Command([b"HGETALL", b"user:1"], value => value.as_string_map())

    RawValue::expect_ok

    source
    fn RawValue::expect_ok(self : RawValue) -> Unit raise

    Succeeds only when the response is OK.

    RawValue::is_null

    source
    fn RawValue::is_null(self : RawValue) -> Bool

    Returns whether the response is Redis null.

    Example:
    @redis.Command([b"GET", b"missing"], value => value.is_null())

    Transaction

    source
    type Transaction

    Transaction context passed to Client::transaction.

    Use it only inside the callback passed to Client::transaction.

    Transaction::append

    source
    async fn Transaction::append(self : Transaction, key : String, value : String) -> Int

    Transaction::decr

    source
    async fn Transaction::decr(self : Transaction, key : String) -> Int

    Transaction::decrby

    source
    async fn Transaction::decrby(self : Transaction, key : String, decrement : Int) -> Int

    Transaction::del

    source
    async fn Transaction::del(self : Transaction, keys : ArrayView[String]) -> Int

    Transaction::echo

    source
    async fn Transaction::echo(self : Transaction, message : String) -> String

    Transaction::exec

    source
    async fn Transaction::exec(self : Transaction, multi : Multi) -> MultiResult?

    Executes commands added to multi with Redis MULTI/EXEC.

    Returns None when watched keys changed before EXEC. Returns Some(result) on success; read individual command results with MultiResult::get.

    Transaction::exists

    source
    async fn Transaction::exists(self : Transaction, keys : ArrayView[String]) -> Int

    Transaction::expire

    source
    async fn Transaction::expire(self : Transaction, key : String, seconds : Int) -> Bool

    Transaction::get

    source
    async fn Transaction::get(self : Transaction, key : String) -> String?

    Transaction::getrange

    source
    async fn Transaction::getrange(self : Transaction, key : String, start : Int, end : Int) -> String

    Transaction::hdel

    source
    async fn Transaction::hdel(self : Transaction, key : String, fields : ArrayView[String]) -> Int

    Transaction::hexists

    source
    async fn Transaction::hexists(self : Transaction, key : String, field : String) -> Bool

    Transaction::hget

    source
    async fn Transaction::hget(self : Transaction, key : String, field : String) -> String?

    Transaction::hgetall

    source
    async fn Transaction::hgetall(self : Transaction, key : String) -> Map[String, String]

    Transaction::hincrby

    source
    async fn Transaction::hincrby(self : Transaction, key : String, field : String, increment : Int) -> Int

    Transaction::hincrbyfloat

    source
    async fn Transaction::hincrbyfloat(self : Transaction, key : String, field : String, increment : Double) -> Double

    Transaction::hkeys

    source
    async fn Transaction::hkeys(self : Transaction, key : String) -> Array[String]

    Transaction::hlen

    source
    async fn Transaction::hlen(self : Transaction, key : String) -> Int

    Transaction::hmget

    source
    async fn Transaction::hmget(self : Transaction, key : String, fields : ArrayView[String]) -> Array[String?]

    Transaction::hmset

    source
    async fn Transaction::hmset(self : Transaction, key : String, fields : ArrayView[(String, String)]) -> Unit

    Transaction::hscan

    source
    async fn Transaction::hscan(self : Transaction, key : String, cursor : String, pattern? : String, count? : Int) -> (String, Map[String, String])

    Transaction::hset

    source
    async fn Transaction::hset(self : Transaction, key : String, field : String, value : String) -> Int

    Transaction::hstrlen

    source
    async fn Transaction::hstrlen(self : Transaction, key : String, field : String) -> Int

    Transaction::hvals

    source
    async fn Transaction::hvals(self : Transaction, key : String) -> Array[String]

    Transaction::incr

    source
    async fn Transaction::incr(self : Transaction, key : String) -> Int

    Transaction::incrby

    source
    async fn Transaction::incrby(self : Transaction, key : String, increment : Int) -> Int

    Transaction::incrbyfloat

    source
    async fn Transaction::incrbyfloat(self : Transaction, key : String, increment : Double) -> Double

    Transaction::keys

    source
    async fn Transaction::keys(self : Transaction, pattern : String) -> Array[String]

    Transaction::lindex

    source
    async fn Transaction::lindex(self : Transaction, key : String, index : Int) -> String?

    Transaction::linsert_after

    source
    async fn Transaction::linsert_after(self : Transaction, key : String, pivot : String, value : String) -> Int

    Transaction::linsert_before

    source
    async fn Transaction::linsert_before(self : Transaction, key : String, pivot : String, value : String) -> Int

    Transaction::llen

    source
    async fn Transaction::llen(self : Transaction, key : String) -> Int

    Transaction::lpop

    source
    async fn Transaction::lpop(self : Transaction, key : String) -> String?

    Transaction::lpop_count

    source
    async fn Transaction::lpop_count(self : Transaction, key : String, count : Int) -> Array[String]

    Transaction::lpush

    source
    async fn Transaction::lpush(self : Transaction, key : String, values : ArrayView[String]) -> Int

    Transaction::lrange

    source
    async fn Transaction::lrange(self : Transaction, key : String, start : Int, stop : Int) -> Array[String]

    Transaction::lrem

    source
    async fn Transaction::lrem(self : Transaction, key : String, count : Int, value : String) -> Int

    Transaction::lset

    source
    async fn Transaction::lset(self : Transaction, key : String, index : Int, value : String) -> Unit

    Transaction::ltrim

    source
    async fn Transaction::ltrim(self : Transaction, key : String, start : Int, stop : Int) -> Unit

    Transaction::mget

    source
    async fn Transaction::mget(self : Transaction, keys : ArrayView[String]) -> Array[String?]

    Transaction::mset

    source
    async fn Transaction::mset(self : Transaction, items : ArrayView[(String, String)]) -> Unit

    Transaction::msetnx

    source
    async fn Transaction::msetnx(self : Transaction, items : ArrayView[(String, String)]) -> Bool

    Transaction::persist

    source
    async fn Transaction::persist(self : Transaction, key : String) -> Bool

    Transaction::pexpire

    source
    async fn Transaction::pexpire(self : Transaction, key : String, milliseconds : Int) -> Bool

    Transaction::ping

    source
    async fn Transaction::ping(self : Transaction, message? : String) -> String

    Transaction::psetex

    source
    async fn Transaction::psetex(self : Transaction, key : String, milliseconds : Int, value : String) -> Unit

    Transaction::pttl

    source
    async fn Transaction::pttl(self : Transaction, key : String) -> Int

    Transaction::randomkey

    source
    async fn Transaction::randomkey(self : Transaction) -> String?

    Transaction::raw_command

    source
    async fn Transaction::raw_command(self : Transaction, args : ArrayView[BytesView]) -> RawValue

    Runs one custom command immediately on the transaction connection.

    This is useful for commands not covered by typed transaction helpers.

    Transaction::rename

    source
    async fn Transaction::rename(self : Transaction, key : String, new_key : String) -> Unit

    Transaction::renamenx

    source
    async fn Transaction::renamenx(self : Transaction, key : String, new_key : String) -> Bool

    Transaction::rpop

    source
    async fn Transaction::rpop(self : Transaction, key : String) -> String?

    Transaction::rpop_count

    source
    async fn Transaction::rpop_count(self : Transaction, key : String, count : Int) -> Array[String]

    Transaction::rpush

    source
    async fn Transaction::rpush(self : Transaction, key : String, values : ArrayView[String]) -> Int

    Transaction::sadd

    source
    async fn Transaction::sadd(self : Transaction, key : String, members : ArrayView[String]) -> Int

    Transaction::scan

    source
    async fn Transaction::scan(self : Transaction, cursor : String, pattern? : String, count? : Int) -> (String, Array[String])

    Transaction::scard

    source
    async fn Transaction::scard(self : Transaction, key : String) -> Int

    Transaction::sdiff

    source
    async fn Transaction::sdiff(self : Transaction, keys : ArrayView[String]) -> 
    HashSet    [String]

    Transaction::sdiffstore

    source
    async fn Transaction::sdiffstore(self : Transaction, destination : String, keys : ArrayView[String]) -> Int

    Transaction::set

    source
    async fn Transaction::set(self : Transaction, key : String, value : String, ex? : Int, px? : Int, nx? : Bool, xx? : Bool) -> Bool

    Transaction::set_get

    source
    async fn Transaction::set_get(self : Transaction, key : String, value : String, ex? : Int, px? : Int, nx? : Bool, xx? : Bool) -> String?

    Transaction::setex

    source
    async fn Transaction::setex(self : Transaction, key : String, seconds : Int, value : String) -> Unit

    Transaction::setnx

    source
    async fn Transaction::setnx(self : Transaction, key : String, value : String) -> Bool

    Transaction::setrange

    source
    async fn Transaction::setrange(self : Transaction, key : String, offset : Int, value : String) -> Int

    Transaction::sinter

    source
    async fn Transaction::sinter(self : Transaction, keys : ArrayView[String]) -> 
    HashSet    [String]

    Transaction::sinterstore

    source
    async fn Transaction::sinterstore(self : Transaction, destination : String, keys : ArrayView[String]) -> Int

    Transaction::sismember

    source
    async fn Transaction::sismember(self : Transaction, key : String, value : String) -> Bool

    Transaction::smembers

    source
    async fn Transaction::smembers(self : Transaction, key : String) -> 
    HashSet    [String]

    Transaction::smismember

    source
    async fn Transaction::smismember(self : Transaction, key : String, members : ArrayView[String]) -> Array[Bool]

    Transaction::smove

    source
    async fn Transaction::smove(self : Transaction, source : String, destination : String, value : String) -> Bool

    Transaction::spop

    source
    async fn Transaction::spop(self : Transaction, key : String) -> String?

    Transaction::spop_count

    source
    async fn Transaction::spop_count(self : Transaction, key : String, count : Int) -> 
    HashSet    [String]

    Transaction::srandmember

    source
    async fn Transaction::srandmember(self : Transaction, key : String) -> String?

    Transaction::srandmember_count

    source
    async fn Transaction::srandmember_count(self : Transaction, key : String, count : Int) -> Array[String]

    Transaction::srem

    source
    async fn Transaction::srem(self : Transaction, key : String, members : ArrayView[String]) -> Int

    Transaction::sscan

    source
    async fn Transaction::sscan(self : Transaction, key : String, cursor : String, pattern? : String, count? : Int) -> (String, 
    HashSet    [String])

    Transaction::strlen

    source
    async fn Transaction::strlen(self : Transaction, key : String) -> Int

    Transaction::sunion

    source
    async fn Transaction::sunion(self : Transaction, keys : ArrayView[String]) -> 
    HashSet    [String]

    Transaction::sunionstore

    source
    async fn Transaction::sunionstore(self : Transaction, destination : String, keys : ArrayView[String]) -> Int

    Transaction::ttl

    source
    async fn Transaction::ttl(self : Transaction, key : String) -> Int

    Transaction::type_

    source
    async fn Transaction::type_(self : Transaction, key : String) -> String

    Transaction::watch

    source
    async fn Transaction::watch(self : Transaction, keys : ArrayView[String]) -> Unit

    Watches keys for optimistic locking.

    If any watched key changes before exec, Transaction::exec returns None.

    Transaction::zadd

    source
    async fn Transaction::zadd(self : Transaction, key : String, items : ArrayView[(String, Double)]) -> Int

    Transaction::zcard

    source
    async fn Transaction::zcard(self : Transaction, key : String) -> Int

    Transaction::zcount

    source
    async fn Transaction::zcount(self : Transaction, key : String, min : Double, max : Double) -> Int

    Transaction::zincrby

    source
    async fn Transaction::zincrby(self : Transaction, key : String, increment : Double, value : String) -> Double

    Transaction::zpopmax

    source
    async fn Transaction::zpopmax(self : Transaction, key : String, count? : Int) -> Array[(String, Double)]

    Transaction::zpopmin

    source
    async fn Transaction::zpopmin(self : Transaction, key : String, count? : Int) -> Array[(String, Double)]

    Transaction::zrange

    source
    async fn Transaction::zrange(self : Transaction, key : String, start : Int, stop : Int) -> Array[String]

    Transaction::zrange_with_scores

    source
    async fn Transaction::zrange_with_scores(self : Transaction, key : String, start : Int, stop : Int) -> Array[(String, Double)]

    Transaction::zrangebyscore

    source
    async fn Transaction::zrangebyscore(self : Transaction, key : String, min : Double, max : Double, offset? : Int, count? : Int) -> Array[String]

    Transaction::zrangebyscore_with_scores

    source
    async fn Transaction::zrangebyscore_with_scores(self : Transaction, key : String, min : Double, max : Double, offset? : Int, count? : Int) -> Array[(String, Double)]

    Transaction::zrank

    source
    async fn Transaction::zrank(self : Transaction, key : String, value : String) -> Int?

    Transaction::zrem

    source
    async fn Transaction::zrem(self : Transaction, key : String, members : ArrayView[String]) -> Int

    Transaction::zremrangebyrank

    source
    async fn Transaction::zremrangebyrank(self : Transaction, key : String, start : Int, stop : Int) -> Int

    Transaction::zremrangebyscore

    source
    async fn Transaction::zremrangebyscore(self : Transaction, key : String, min : Double, max : Double) -> Int

    Transaction::zrevrange

    source
    async fn Transaction::zrevrange(self : Transaction, key : String, start : Int, stop : Int) -> Array[String]

    Transaction::zrevrange_with_scores

    source
    async fn Transaction::zrevrange_with_scores(self : Transaction, key : String, start : Int, stop : Int) -> Array[(String, Double)]

    Transaction::zrevrank

    source
    async fn Transaction::zrevrank(self : Transaction, key : String, value : String) -> Int?

    Transaction::zscan

    source
    async fn Transaction::zscan(self : Transaction, key : String, cursor : String, pattern? : String, count? : Int) -> (String, Array[(String, Double)])

    Transaction::zscore

    source
    async fn Transaction::zscore(self : Transaction, key : String, value : String) -> Double?

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io