Implementation detail. Returns new Listener.

Implementation detail.

`ACL` - Redis command function.
  Available since: Redis 6.0.0
       Complexity: Depends on subcommand.

A container for Access List Control commands.
Ref. https://redis.io/commands/acl/ for more info.

`ACL CAT` - Redis command function.
  Available since: Redis 6.0.0
       Complexity: O(1) since the categories and commands are a fixed set.

Lists the ACL categories, or the commands inside a category.
Ref. https://redis.io/commands/acl-cat/ for more info.

`ACL DELUSER` - Redis command function.
  Available since: Redis 6.0.0
       Complexity: O(1) amortized time considering the typical user.

Deletes ACL users, and terminates their connections.
Ref. https://redis.io/commands/acl-deluser/ for more info.

`ACL DRYRUN` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(1).

Simulates the execution of a command by a user, without executing the command.
Ref. https://redis.io/commands/acl-dryrun/ for more info.

`ACL GENPASS` - Redis command function.
  Available since: Redis 6.0.0
       Complexity: O(1)

Generates a pseudorandom, secure password that can be used to identify ACL users.
Ref. https://redis.io/commands/acl-genpass/ for more info.

`ACL GETUSER` - Redis command function.
  Available since: Redis 6.0.0
       Complexity: O(N). Where N is the number of password, command and pattern rules that the user has.

Lists the ACL rules of a user.
Ref. https://redis.io/commands/acl-getuser/ for more info.

`ACL HELP` - Redis command function.
  Available since: Redis 6.0.0
       Complexity: O(1)

Returns helpful text about the different subcommands.
Ref. https://redis.io/commands/acl-help/ for more info.

`ACL LIST` - Redis command function.
  Available since: Redis 6.0.0
       Complexity: O(N). Where N is the number of configured users.

Dumps the effective rules in ACL file format.
Ref. https://redis.io/commands/acl-list/ for more info.

`ACL LOAD` - Redis command function.
  Available since: Redis 6.0.0
       Complexity: O(N). Where N is the number of configured users.

Reloads the rules from the configured ACL file.
Ref. https://redis.io/commands/acl-load/ for more info.

`ACL LOG` - Redis command function.
  Available since: Redis 6.0.0
       Complexity: O(N) with N being the number of entries shown.

Lists recent security events generated due to ACL rules.
Ref. https://redis.io/commands/acl-log/ for more info.

`ACL SAVE` - Redis command function.
  Available since: Redis 6.0.0
       Complexity: O(N). Where N is the number of configured users.

Saves the effective ACL rules in the configured ACL file.
Ref. https://redis.io/commands/acl-save/ for more info.

`ACL SETUSER` - Redis command function.
  Available since: Redis 6.0.0
       Complexity: O(N). Where N is the number of rules provided.

Creates and modifies an ACL user and its rules.
Ref. https://redis.io/commands/acl-setuser/ for more info.

`ACL USERS` - Redis command function.
  Available since: Redis 6.0.0
       Complexity: O(N). Where N is the number of configured users.

Lists all ACL users.
Ref. https://redis.io/commands/acl-users/ for more info.

`ACL WHOAMI` - Redis command function.
  Available since: Redis 6.0.0
       Complexity: O(1)

Returns the authenticated username of the current connection.
Ref. https://redis.io/commands/acl-whoami/ for more info.

`APPEND` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(1). The amortized time complexity is O(1) assuming the appended value is small and the already present value is of any size, since the dynamic string library used by Redis will double the free space available on every reallocation.

Appends a string to the value of a key. Creates the key if it doesn't exist.
Ref. https://redis.io/commands/append/ for more info.

`ASKING` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(1)

Signals that a cluster client is following an -ASK redirect.
Ref. https://redis.io/commands/asking/ for more info.

Alpha - subject to change!
Tool to ease Redis transactions for fun & profit. Wraps body in a `wcar`
call that terminates with `exec`, cleans up reply, and supports automatic
retry for failed optimistic locking.

Body must contain a `multi` call and may contain calls to: `watch`, `unwatch`,
`discard`, etc. Ref. http://redis.io/topics/transactions for more info.

`return` and `parse` NOT supported after `multi` has been called.

Like `swap!` fn, body may be called multiple times so should avoid impure or
expensive ops.

;;; Atomically increment integer key without using INCR
(atomic {} 100 ; Retry <= 100 times on failed optimistic lock, or throw ex

  (watch  :my-int-key) ; Watch key for changes
  (let [;; You can grab the value of the watched key using
        ;; `with-replies` (on the current connection), or
        ;; a nested `wcar` (on a new connection):
        curr-val (or (as-long (with-replies (get :my-int-key))) 0)]

    (return curr-val)

    (multi) ; Start the transaction
      (set :my-int-key (inc curr-val))
      (get :my-int-key)
    ))
=> [["OK" nil "OK" "QUEUED" "QUEUED"] ; Prelude replies
    ["OK" "1"] ; Transaction replies (`exec` reply)
    ]

See also `lua` as alternative way to get transactional behaviour.

Alpha - subject to change. Low-level transaction util.

`AUTH` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N) where N is the number of passwords defined for the user

Authenticates the connection.
Ref. https://redis.io/commands/auth/ for more info.

`BGREWRITEAOF` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Asynchronously rewrites the append-only file to disk.
Ref. https://redis.io/commands/bgrewriteaof/ for more info.

`BGSAVE` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Asynchronously saves the database(s) to disk.
Ref. https://redis.io/commands/bgsave/ for more info.

`BITCOUNT` - Redis command function.
  Available since: Redis 2.6.0
       Complexity: O(N)

Counts the number of set bits (population counting) in a string.
Ref. https://redis.io/commands/bitcount/ for more info.

`BITFIELD` - Redis command function.
  Available since: Redis 3.2.0
       Complexity: O(1) for each subcommand specified

Performs arbitrary bitfield integer operations on strings.
Ref. https://redis.io/commands/bitfield/ for more info.

`BITFIELD_RO` - Redis command function.
  Available since: Redis 6.0.0
       Complexity: O(1) for each subcommand specified

Performs arbitrary read-only bitfield integer operations on strings.
Ref. https://redis.io/commands/bitfield_ro/ for more info.

`BITOP` - Redis command function.
  Available since: Redis 2.6.0
       Complexity: O(N)

Performs bitwise operations on multiple strings, and stores the result.
Ref. https://redis.io/commands/bitop/ for more info.

`BITPOS` - Redis command function.
  Available since: Redis 2.8.7
       Complexity: O(N)

Finds the first set (1) or clear (0) bit in a string.
Ref. https://redis.io/commands/bitpos/ for more info.

`BLMOVE` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(1)

Pops an element from a list, pushes it to another list and returns it. Blocks until an element is available otherwise. Deletes the list if the last element was moved.
Ref. https://redis.io/commands/blmove/ for more info.

`BLMPOP` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(N+M) where N is the number of provided keys and M is the number of elements returned.

Pops the first element from one of multiple lists. Blocks until an element is available otherwise. Deletes the list if the last element was popped.
Ref. https://redis.io/commands/blmpop/ for more info.

`BLPOP` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(N) where N is the number of provided keys.

Removes and returns the first element in a list. Blocks until an element is available otherwise. Deletes the list if the last element was popped.
Ref. https://redis.io/commands/blpop/ for more info.

`BRPOP` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(N) where N is the number of provided keys.

Removes and returns the last element in a list. Blocks until an element is available otherwise. Deletes the list if the last element was popped.
Ref. https://redis.io/commands/brpop/ for more info.

`BRPOPLPUSH` - Redis command function.
  Available since: Redis 2.2.0
       Complexity: O(1)

Pops an element from a list, pushes it to another list and returns it. Block until an element is available otherwise. Deletes the list if the last element was popped.
Ref. https://redis.io/commands/brpoplpush/ for more info.

`BZMPOP` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(K) + O(M*log(N)) where K is the number of provided keys, N being the number of elements in the sorted set, and M being the number of elements popped.

Removes and returns a member by score from one or more sorted sets. Blocks until a member is available otherwise. Deletes the sorted set if the last element was popped.
Ref. https://redis.io/commands/bzmpop/ for more info.

`BZPOPMAX` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(log(N)) with N being the number of elements in the sorted set.

Removes and returns the member with the highest score from one or more sorted sets. Blocks until a member available otherwise.  Deletes the sorted set if the last element was popped.
Ref. https://redis.io/commands/bzpopmax/ for more info.

`BZPOPMIN` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(log(N)) with N being the number of elements in the sorted set.

Removes and returns the member with the lowest score from one or more sorted sets. Blocks until a member is available otherwise. Deletes the sorted set if the last element was popped.
Ref. https://redis.io/commands/bzpopmin/ for more info.

`CLIENT` - Redis command function.
  Available since: Redis 2.4.0
       Complexity: Depends on subcommand.

A container for client connection commands.
Ref. https://redis.io/commands/client/ for more info.

`CLIENT CACHING` - Redis command function.
  Available since: Redis 6.0.0
       Complexity: O(1)

Instructs the server whether to track the keys in the next request.
Ref. https://redis.io/commands/client-caching/ for more info.

`CLIENT GETNAME` - Redis command function.
  Available since: Redis 2.6.9
       Complexity: O(1)

Returns the name of the connection.
Ref. https://redis.io/commands/client-getname/ for more info.

`CLIENT GETREDIR` - Redis command function.
  Available since: Redis 6.0.0
       Complexity: O(1)

Returns the client ID to which the connection's tracking notifications are redirected.
Ref. https://redis.io/commands/client-getredir/ for more info.

`CLIENT HELP` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(1)

Returns helpful text about the different subcommands.
Ref. https://redis.io/commands/client-help/ for more info.

`CLIENT ID` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(1)

Returns the unique client ID of the connection.
Ref. https://redis.io/commands/client-id/ for more info.

`CLIENT INFO` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(1)

Returns information about the connection.
Ref. https://redis.io/commands/client-info/ for more info.

`CLIENT KILL` - Redis command function.
  Available since: Redis 2.4.0
       Complexity: O(N) where N is the number of client connections

Terminates open connections.
Ref. https://redis.io/commands/client-kill/ for more info.

`CLIENT LIST` - Redis command function.
  Available since: Redis 2.4.0
       Complexity: O(N) where N is the number of client connections

Lists open connections.
Ref. https://redis.io/commands/client-list/ for more info.

`CLIENT NO-EVICT` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(1)

Sets the client eviction mode of the connection.
Ref. https://redis.io/commands/client-no-evict/ for more info.

`CLIENT NO-TOUCH` - Redis command function.
  Available since: Redis 7.2.0
       Complexity: O(1)

Controls whether commands sent by the client affect the LRU/LFU of accessed keys.
Ref. https://redis.io/commands/client-no-touch/ for more info.

`CLIENT PAUSE` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(1)

Suspends commands processing.
Ref. https://redis.io/commands/client-pause/ for more info.

`CLIENT REPLY` - Redis command function.
  Available since: Redis 3.2.0
       Complexity: O(1)

Instructs the server whether to reply to commands.
Ref. https://redis.io/commands/client-reply/ for more info.

`CLIENT SETINFO` - Redis command function.
  Available since: Redis 7.2.0
       Complexity: O(1)

Sets information specific to the client or connection.
Ref. https://redis.io/commands/client-setinfo/ for more info.

`CLIENT SETNAME` - Redis command function.
  Available since: Redis 2.6.9
       Complexity: O(1)

Sets the connection name.
Ref. https://redis.io/commands/client-setname/ for more info.

`CLIENT TRACKING` - Redis command function.
  Available since: Redis 6.0.0
       Complexity: O(1). Some options may introduce additional complexity.

Controls server-assisted client-side caching for the connection.
Ref. https://redis.io/commands/client-tracking/ for more info.

`CLIENT TRACKINGINFO` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(1)

Returns information about server-assisted client-side caching for the connection.
Ref. https://redis.io/commands/client-trackinginfo/ for more info.

`CLIENT UNBLOCK` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(log N) where N is the number of client connections

Unblocks a client blocked by a blocking command from a different connection.
Ref. https://redis.io/commands/client-unblock/ for more info.

`CLIENT UNPAUSE` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(N) Where N is the number of paused clients

Resumes processing commands from paused clients.
Ref. https://redis.io/commands/client-unpause/ for more info.

`CLUSTER` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: Depends on subcommand.

A container for Redis Cluster commands.
Ref. https://redis.io/commands/cluster/ for more info.

`CLUSTER ADDSLOTS` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(N) where N is the total number of hash slot arguments

Assigns new hash slots to a node.
Ref. https://redis.io/commands/cluster-addslots/ for more info.

`CLUSTER ADDSLOTSRANGE` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(N) where N is the total number of the slots between the start slot and end slot arguments.

Assigns new hash slot ranges to a node.
Ref. https://redis.io/commands/cluster-addslotsrange/ for more info.

`CLUSTER BUMPEPOCH` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(1)

Advances the cluster config epoch.
Ref. https://redis.io/commands/cluster-bumpepoch/ for more info.

`CLUSTER COUNT-FAILURE-REPORTS` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(N) where N is the number of failure reports

Returns the number of active failure reports active for a node.
Ref. https://redis.io/commands/cluster-count-failure-reports/ for more info.

`CLUSTER COUNTKEYSINSLOT` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(1)

Returns the number of keys in a hash slot.
Ref. https://redis.io/commands/cluster-countkeysinslot/ for more info.

`CLUSTER DELSLOTS` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(N) where N is the total number of hash slot arguments

Sets hash slots as unbound for a node.
Ref. https://redis.io/commands/cluster-delslots/ for more info.

`CLUSTER DELSLOTSRANGE` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(N) where N is the total number of the slots between the start slot and end slot arguments.

Sets hash slot ranges as unbound for a node.
Ref. https://redis.io/commands/cluster-delslotsrange/ for more info.

`CLUSTER FAILOVER` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(1)

Forces a replica to perform a manual failover of its master.
Ref. https://redis.io/commands/cluster-failover/ for more info.

`CLUSTER FLUSHSLOTS` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(1)

Deletes all slots information from a node.
Ref. https://redis.io/commands/cluster-flushslots/ for more info.

`CLUSTER FORGET` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(1)

Removes a node from the nodes table.
Ref. https://redis.io/commands/cluster-forget/ for more info.

`CLUSTER GETKEYSINSLOT` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(N) where N is the number of requested keys

Returns the key names in a hash slot.
Ref. https://redis.io/commands/cluster-getkeysinslot/ for more info.

`CLUSTER HELP` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(1)

Returns helpful text about the different subcommands.
Ref. https://redis.io/commands/cluster-help/ for more info.

`CLUSTER INFO` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(1)

Returns information about the state of a node.
Ref. https://redis.io/commands/cluster-info/ for more info.

`CLUSTER KEYSLOT` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(N) where N is the number of bytes in the key

Returns the hash slot for a key.
Ref. https://redis.io/commands/cluster-keyslot/ for more info.

`CLUSTER LINKS` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(N) where N is the total number of Cluster nodes

Returns a list of all TCP links to and from peer nodes.
Ref. https://redis.io/commands/cluster-links/ for more info.

`CLUSTER MEET` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(1)

Forces a node to handshake with another node.
Ref. https://redis.io/commands/cluster-meet/ for more info.

`CLUSTER MYID` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(1)

Returns the ID of a node.
Ref. https://redis.io/commands/cluster-myid/ for more info.

`CLUSTER MYSHARDID` - Redis command function.
  Available since: Redis 7.2.0
       Complexity: O(1)

Returns the shard ID of a node.
Ref. https://redis.io/commands/cluster-myshardid/ for more info.

`CLUSTER NODES` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(N) where N is the total number of Cluster nodes

Returns the cluster configuration for a node.
Ref. https://redis.io/commands/cluster-nodes/ for more info.

`CLUSTER REPLICAS` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(N) where N is the number of replicas.

Lists the replica nodes of a master node.
Ref. https://redis.io/commands/cluster-replicas/ for more info.

`CLUSTER REPLICATE` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(1)

Configure a node as replica of a master node.
Ref. https://redis.io/commands/cluster-replicate/ for more info.

`CLUSTER RESET` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(N) where N is the number of known nodes. The command may execute a FLUSHALL as a side effect.

Resets a node.
Ref. https://redis.io/commands/cluster-reset/ for more info.

`CLUSTER SAVECONFIG` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(1)

Forces a node to save the cluster configuration to disk.
Ref. https://redis.io/commands/cluster-saveconfig/ for more info.

`CLUSTER SET-CONFIG-EPOCH` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(1)

Sets the configuration epoch for a new node.
Ref. https://redis.io/commands/cluster-set-config-epoch/ for more info.

`CLUSTER SETSLOT` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(1)

Binds a hash slot to a node.
Ref. https://redis.io/commands/cluster-setslot/ for more info.

`CLUSTER SHARDS` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(N) where N is the total number of cluster nodes

Returns the mapping of cluster slots to shards.
Ref. https://redis.io/commands/cluster-shards/ for more info.

`CLUSTER SLAVES` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(N) where N is the number of replicas.

Lists the replica nodes of a master node.
Ref. https://redis.io/commands/cluster-slaves/ for more info.

`CLUSTER SLOTS` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(N) where N is the total number of Cluster nodes

Returns the mapping of cluster slots to nodes.
Ref. https://redis.io/commands/cluster-slots/ for more info.

`COMMAND` - Redis command function.
  Available since: Redis 2.8.13
       Complexity: O(N) where N is the total number of Redis commands

Returns detailed information about all commands.
Ref. https://redis.io/commands/command/ for more info.

`COMMAND COUNT` - Redis command function.
  Available since: Redis 2.8.13
       Complexity: O(1)

Returns a count of commands.
Ref. https://redis.io/commands/command-count/ for more info.

`COMMAND DOCS` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(N) where N is the number of commands to look up

Returns documentary information about one, multiple or all commands.
Ref. https://redis.io/commands/command-docs/ for more info.

`COMMAND GETKEYS` - Redis command function.
  Available since: Redis 2.8.13
       Complexity: O(N) where N is the number of arguments to the command

Extracts the key names from an arbitrary command.
Ref. https://redis.io/commands/command-getkeys/ for more info.

`COMMAND GETKEYSANDFLAGS` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(N) where N is the number of arguments to the command

Extracts the key names and access flags for an arbitrary command.
Ref. https://redis.io/commands/command-getkeysandflags/ for more info.

`COMMAND HELP` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(1)

Returns helpful text about the different subcommands.
Ref. https://redis.io/commands/command-help/ for more info.

`COMMAND INFO` - Redis command function.
  Available since: Redis 2.8.13
       Complexity: O(N) where N is the number of commands to look up

Returns information about one, multiple or all commands.
Ref. https://redis.io/commands/command-info/ for more info.

`COMMAND LIST` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(N) where N is the total number of Redis commands

Returns a list of command names.
Ref. https://redis.io/commands/command-list/ for more info.

Experimental.

Experimental.

`CONFIG` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: Depends on subcommand.

A container for server configuration commands.
Ref. https://redis.io/commands/config/ for more info.

`CONFIG GET` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(N) when N is the number of configuration parameters provided

Returns the effective values of configuration parameters.
Ref. https://redis.io/commands/config-get/ for more info.

`CONFIG HELP` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(1)

Returns helpful text about the different subcommands.
Ref. https://redis.io/commands/config-help/ for more info.

`CONFIG RESETSTAT` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(1)

Resets the server's statistics.
Ref. https://redis.io/commands/config-resetstat/ for more info.

`CONFIG REWRITE` - Redis command function.
  Available since: Redis 2.8.0
       Complexity: O(1)

Persists the effective configuration to file.
Ref. https://redis.io/commands/config-rewrite/ for more info.

`CONFIG SET` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(N) when N is the number of configuration parameters provided

Sets configuration parameters in-flight.
Ref. https://redis.io/commands/config-set/ for more info.

Returns a new, stateful connection pool for use with `wcar`.
Backed by Apache Commons Pool 2's `GenericKeyedObjectPool`.

Pool opts include:
  - :test-on-borrow?   ; Test conn health on acquisition from pool? (Default false)
  - :test-on-return?   ; Test conn health on return      to   pool? (Default false)
  - :test-on-idle?     ; Test conn health while idle in pool?       (Default true)

  - :min-idle-per-key  ; Min num of idle conns to keep per sub-pool (Default 0)
  - :max-idle-per-key  ; Max num of idle conns to keep per sub-pool (Default 16)
  - :max-total-per-key ; Max num of idle or active conns <...>      (Default 16)

Pool can be shutdown with the `java.io.Closeable` `close` method.
This will in turn call the `GenericKeyedObjectPool`'s `close` method.

Example:

  (defonce my-pool (car/connection-pool {:test-on-borrow? true})) ; Create pool
  (wcar {:pool my-pool} (car/ping)) ; Use pool

  (.close my-pool) ; Initiate permanent shutdown of pool
  ;; Note: pool shutdown does NOT interrupt active connections.
  ;; It will prevent any new connections, and will destroy any idle or
  ;; returned connections.

`COPY` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(N) worst case for collections, where N is the number of nested items. O(1) for string values.

Copies the value of a key to a new key.
Ref. https://redis.io/commands/copy/ for more info.

`DBSIZE` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Returns the number of keys in the database.
Ref. https://redis.io/commands/dbsize/ for more info.

`DEBUG` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: Depends on subcommand.

A container for debugging commands.
Ref. https://redis.io/commands/debug/ for more info.

`DECR` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Decrements the integer value of a key by one. Uses 0 as initial value if the key doesn't exist.
Ref. https://redis.io/commands/decr/ for more info.

`DECRBY` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Decrements a number from the integer value of a key. Uses 0 as initial value if the key doesn't exist.
Ref. https://redis.io/commands/decrby/ for more info.

`DEL` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N) where N is the number of keys that will be removed. When a key to remove holds a value other than a string, the individual complexity for this key is O(M) where M is the number of elements in the list, set, sorted set or hash. Removing a single key that holds a string value is O(1).

Deletes one or more keys.
Ref. https://redis.io/commands/del/ for more info.

`DISCARD` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(N), when N is the number of queued commands

Discards a transaction.
Ref. https://redis.io/commands/discard/ for more info.

`DUMP` - Redis command function.
  Available since: Redis 2.6.0
       Complexity: O(1) to access the key and additional O(N*M) to serialize it, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1*M) where M is small, so simply O(1).

Returns a serialized representation of the value stored at a key.
Ref. https://redis.io/commands/dump/ for more info.

`ECHO` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Returns the given string.
Ref. https://redis.io/commands/echo/ for more info.

`EVAL` - Redis command function.
  Available since: Redis 2.6.0
       Complexity: Depends on the script that is executed.

Executes a server-side Lua script.
Ref. https://redis.io/commands/eval/ for more info.

Optimistically tries to send `evalsha` command for given script. In the event
of a "NOSCRIPT" reply, reattempts with `eval`. Returns the final command's
reply. Redis Cluster note: keys need to all be on same shard.

`EVAL_RO` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: Depends on the script that is executed.

Executes a read-only server-side Lua script.
Ref. https://redis.io/commands/eval_ro/ for more info.

`EVALSHA` - Redis command function.
  Available since: Redis 2.6.0
       Complexity: Depends on the script that is executed.

Executes a server-side Lua script by SHA1 digest.
Ref. https://redis.io/commands/evalsha/ for more info.

Like `evalsha` but automatically computes SHA1 hash for script.

`EVALSHA_RO` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: Depends on the script that is executed.

Executes a read-only server-side Lua script by SHA1 digest.
Ref. https://redis.io/commands/evalsha_ro/ for more info.

`EXEC` - Redis command function.
  Available since: Redis 1.2.0
       Complexity: Depends on commands in the transaction

Executes all commands in a transaction.
Ref. https://redis.io/commands/exec/ for more info.

`EXISTS` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N) where N is the number of keys to check.

Determines whether one or more keys exist.
Ref. https://redis.io/commands/exists/ for more info.

`EXPIRE` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Sets the expiration time of a key in seconds.
Ref. https://redis.io/commands/expire/ for more info.

`EXPIREAT` - Redis command function.
  Available since: Redis 1.2.0
       Complexity: O(1)

Sets the expiration time of a key to a Unix timestamp.
Ref. https://redis.io/commands/expireat/ for more info.

`EXPIRETIME` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(1)

Returns the expiration time of a key as a Unix timestamp.
Ref. https://redis.io/commands/expiretime/ for more info.

`FAILOVER` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(1)

Starts a coordinated failover from a server to one of its replicas.
Ref. https://redis.io/commands/failover/ for more info.

`FCALL` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: Depends on the function that is executed.

Invokes a function.
Ref. https://redis.io/commands/fcall/ for more info.

`FCALL_RO` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: Depends on the function that is executed.

Invokes a read-only function.
Ref. https://redis.io/commands/fcall_ro/ for more info.

`FLUSHALL` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N) where N is the total number of keys in all databases

Removes all keys from all databases.
Ref. https://redis.io/commands/flushall/ for more info.

`FLUSHDB` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N) where N is the number of keys in the selected database

Remove all keys from the current database.
Ref. https://redis.io/commands/flushdb/ for more info.

Forces argument of any type (incl. keywords, simple numbers, and binary types)
to be subject to automatic de/serialization with Nippy.

`FUNCTION` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: Depends on subcommand.

A container for function commands.
Ref. https://redis.io/commands/function/ for more info.

`FUNCTION DELETE` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(1)

Deletes a library and its functions.
Ref. https://redis.io/commands/function-delete/ for more info.

`FUNCTION DUMP` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(N) where N is the number of functions

Dumps all libraries into a serialized binary payload.
Ref. https://redis.io/commands/function-dump/ for more info.

`FUNCTION FLUSH` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(N) where N is the number of functions deleted

Deletes all libraries and functions.
Ref. https://redis.io/commands/function-flush/ for more info.

`FUNCTION HELP` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(1)

Returns helpful text about the different subcommands.
Ref. https://redis.io/commands/function-help/ for more info.

`FUNCTION KILL` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(1)

Terminates a function during execution.
Ref. https://redis.io/commands/function-kill/ for more info.

`FUNCTION LIST` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(N) where N is the number of functions

Returns information about all libraries.
Ref. https://redis.io/commands/function-list/ for more info.

`FUNCTION LOAD` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(1) (considering compilation time is redundant)

Creates a library.
Ref. https://redis.io/commands/function-load/ for more info.

`FUNCTION RESTORE` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(N) where N is the number of functions on the payload

Restores all libraries from a payload.
Ref. https://redis.io/commands/function-restore/ for more info.

`FUNCTION STATS` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(1)

Returns information about a function during execution.
Ref. https://redis.io/commands/function-stats/ for more info.

`GEOADD` - Redis command function.
  Available since: Redis 3.2.0
       Complexity: O(log(N)) for each item added, where N is the number of elements in the sorted set.

Adds one or more members to a geospatial index. The key is created if it doesn't exist.
Ref. https://redis.io/commands/geoadd/ for more info.

`GEODIST` - Redis command function.
  Available since: Redis 3.2.0
       Complexity: O(1)

Returns the distance between two members of a geospatial index.
Ref. https://redis.io/commands/geodist/ for more info.

`GEOHASH` - Redis command function.
  Available since: Redis 3.2.0
       Complexity: O(1) for each member requested.

Returns members from a geospatial index as geohash strings.
Ref. https://redis.io/commands/geohash/ for more info.

`GEOPOS` - Redis command function.
  Available since: Redis 3.2.0
       Complexity: O(1) for each member requested.

Returns the longitude and latitude of members from a geospatial index.
Ref. https://redis.io/commands/geopos/ for more info.

`GEORADIUS` - Redis command function.
  Available since: Redis 3.2.0
       Complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.

Queries a geospatial index for members within a distance from a coordinate, optionally stores the result.
Ref. https://redis.io/commands/georadius/ for more info.

`GEORADIUS_RO` - Redis command function.
  Available since: Redis 3.2.10
       Complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.

Returns members from a geospatial index that are within a distance from a coordinate.
Ref. https://redis.io/commands/georadius_ro/ for more info.

`GEORADIUSBYMEMBER` - Redis command function.
  Available since: Redis 3.2.0
       Complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.

Queries a geospatial index for members within a distance from a member, optionally stores the result.
Ref. https://redis.io/commands/georadiusbymember/ for more info.

`GEORADIUSBYMEMBER_RO` - Redis command function.
  Available since: Redis 3.2.10
       Complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.

Returns members from a geospatial index that are within a distance from a member.
Ref. https://redis.io/commands/georadiusbymember_ro/ for more info.

`GEOSEARCH` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape

Queries a geospatial index for members inside an area of a box or a circle.
Ref. https://redis.io/commands/geosearch/ for more info.

`GEOSEARCHSTORE` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape

Queries a geospatial index for members inside an area of a box or a circle, optionally stores the result.
Ref. https://redis.io/commands/geosearchstore/ for more info.

`GET` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Returns the string value of a key.
Ref. https://redis.io/commands/get/ for more info.

`GETBIT` - Redis command function.
  Available since: Redis 2.2.0
       Complexity: O(1)

Returns a bit value by offset.
Ref. https://redis.io/commands/getbit/ for more info.

`GETDEL` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(1)

Returns the string value of a key after deleting the key.
Ref. https://redis.io/commands/getdel/ for more info.

`GETEX` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(1)

Returns the string value of a key after setting its expiration time.
Ref. https://redis.io/commands/getex/ for more info.

`GETRANGE` - Redis command function.
  Available since: Redis 2.4.0
       Complexity: O(N) where N is the length of the returned string. The complexity is ultimately determined by the returned length, but because creating a substring from an existing string is very cheap, it can be considered O(1) for small strings.

Returns a substring of the string stored at a key.
Ref. https://redis.io/commands/getrange/ for more info.

`GETSET` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Returns the previous string value of a key after setting it to a new value.
Ref. https://redis.io/commands/getset/ for more info.

`HDEL` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(N) where N is the number of fields to be removed.

Deletes one or more fields and their values from a hash. Deletes the hash if no fields remain.
Ref. https://redis.io/commands/hdel/ for more info.

`HELLO` - Redis command function.
  Available since: Redis 6.0.0
       Complexity: O(1)

Handshakes with the Redis server.
Ref. https://redis.io/commands/hello/ for more info.

`HEXISTS` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(1)

Determines whether a field exists in a hash.
Ref. https://redis.io/commands/hexists/ for more info.

`HGET` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(1)

Returns the value of a field in a hash.
Ref. https://redis.io/commands/hget/ for more info.

`HGETALL` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(N) where N is the size of the hash.

Returns all fields and values in a hash.
Ref. https://redis.io/commands/hgetall/ for more info.

`HINCRBY` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(1)

Increments the integer value of a field in a hash by a number. Uses 0 as initial value if the field doesn't exist.
Ref. https://redis.io/commands/hincrby/ for more info.

`HINCRBYFLOAT` - Redis command function.
  Available since: Redis 2.6.0
       Complexity: O(1)

Increments the floating point value of a field by a number. Uses 0 as initial value if the field doesn't exist.
Ref. https://redis.io/commands/hincrbyfloat/ for more info.

`HKEYS` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(N) where N is the size of the hash.

Returns all fields in a hash.
Ref. https://redis.io/commands/hkeys/ for more info.

`HLEN` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(1)

Returns the number of fields in a hash.
Ref. https://redis.io/commands/hlen/ for more info.

`HMGET` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(N) where N is the number of fields being requested.

Returns the values of all fields in a hash.
Ref. https://redis.io/commands/hmget/ for more info.

`HMSET` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(N) where N is the number of fields being set.

Sets the values of multiple fields.
Ref. https://redis.io/commands/hmset/ for more info.

Like `hmset` but takes a map argument.

Experimental.

`HRANDFIELD` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(N) where N is the number of fields returned

Returns one or more random fields from a hash.
Ref. https://redis.io/commands/hrandfield/ for more info.

`HSCAN` - Redis command function.
  Available since: Redis 2.8.0
       Complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection.

Iterates over fields and values of a hash.
Ref. https://redis.io/commands/hscan/ for more info.

`HSET` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(1) for each field/value pair added, so O(N) to add N field/value pairs when the command is called with multiple field/value pairs.

Creates or modifies the value of a field in a hash.
Ref. https://redis.io/commands/hset/ for more info.

`HSETNX` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(1)

Sets the value of a field in a hash only when the field doesn't exist.
Ref. https://redis.io/commands/hsetnx/ for more info.

`HSTRLEN` - Redis command function.
  Available since: Redis 3.2.0
       Complexity: O(1)

Returns the length of the value of a field.
Ref. https://redis.io/commands/hstrlen/ for more info.

Experimental.

`HVALS` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(N) where N is the size of the hash.

Returns all values in a hash.
Ref. https://redis.io/commands/hvals/ for more info.

`INCR` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Increments the integer value of a key by one. Uses 0 as initial value if the key doesn't exist.
Ref. https://redis.io/commands/incr/ for more info.

`INCRBY` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Increments the integer value of a key by a number. Uses 0 as initial value if the key doesn't exist.
Ref. https://redis.io/commands/incrby/ for more info.

`INCRBYFLOAT` - Redis command function.
  Available since: Redis 2.6.0
       Complexity: O(1)

Increment the floating point value of a key by a number. Uses 0 as initial value if the key doesn't exist.
Ref. https://redis.io/commands/incrbyfloat/ for more info.

`INFO` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Returns information and statistics about the server.
Ref. https://redis.io/commands/info/ for more info.

Like `info` but automatically coerces reply into a hash-map.

Workaround for Carmine issue #83.

Correct/intended behaviour:
  - Byte arrays written with Carmine are read back as byte arrays.

Break introduced in v2.6.0 (April 1st 2014), issue #83:
  - Byte arrays written with Carmine are accidentally serialized
    with Nippy, and read back as serialized byte arrays.

Workaround introduced in v2.6.1 (May 1st 2014), issue #83:
  - To help folks who had written binary data under v2.6.0,
    Carmine started trying to auto-deserialize byte arrays that
    start with the standard 4-byte Nippy header byte sequence.

    Benefits:
      b1. Folks affected by the earlier breakage can now read back
          their byte arrays as expected.

    Costs:
      c1. A very minor performance hit when reading binary values
          (because of check for a possible Nippy header).

      c2. May encourage possible dependence on the workaround if
          folks start pre-serializing Nippy data sent to Carmine,
          expecting it to be auto-thawed on read.

c2 in particular means that it will probably never be safe to
disable this workaround by default.

However folks starting with Carmine after v2.6.1 and who have
never pre-serialized Nippy data written with Carmine may prefer
to disable the workaround.

If you're not sure what this is or if it's safe to change, you
should probably leave it at the default (true) value.

To change the default (true) value:

  - Call `(alter-var-root #'taoensso.carmine/issue-83-workaround? (fn [_] false))`,
  - or set one of the following to "false" or "FALSE":
    - `taoensso.carmine.issue-83-workaround` JVM property
    - `TAOENSSO_CARMINE_ISSUE_83_WORKAROUND` env var

Ref. https://github.com/ptaoussanis/carmine/issues/83 for more info.

Joins parts to form an idiomatic compound Redis key name. Suggested style:
* "category:subcategory:id:field" basic form.
* Singular category names ("account" rather than "accounts").
* Plural _field_ names when appropriate ("account:friends").
* Dashes for long names ("email-address" rather than "emailAddress", etc.).

`KEYS` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N) with N being the number of keys in the database, under the assumption that the key names in the database and the given pattern have limited length.

Returns all key names that match a pattern.
Ref. https://redis.io/commands/keys/ for more info.

`LASTSAVE` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Returns the Unix timestamp of the last successful save to disk.
Ref. https://redis.io/commands/lastsave/ for more info.

`LATENCY` - Redis command function.
  Available since: Redis 2.8.13
       Complexity: Depends on subcommand.

A container for latency diagnostics commands.
Ref. https://redis.io/commands/latency/ for more info.

`LATENCY DOCTOR` - Redis command function.
  Available since: Redis 2.8.13
       Complexity: O(1)

Returns a human-readable latency analysis report.
Ref. https://redis.io/commands/latency-doctor/ for more info.

`LATENCY GRAPH` - Redis command function.
  Available since: Redis 2.8.13
       Complexity: O(1)

Returns a latency graph for an event.
Ref. https://redis.io/commands/latency-graph/ for more info.

`LATENCY HELP` - Redis command function.
  Available since: Redis 2.8.13
       Complexity: O(1)

Returns helpful text about the different subcommands.
Ref. https://redis.io/commands/latency-help/ for more info.

`LATENCY HISTOGRAM` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(N) where N is the number of commands with latency information being retrieved.

Returns the cumulative distribution of latencies of a subset or all commands.
Ref. https://redis.io/commands/latency-histogram/ for more info.

`LATENCY HISTORY` - Redis command function.
  Available since: Redis 2.8.13
       Complexity: O(1)

Returns timestamp-latency samples for an event.
Ref. https://redis.io/commands/latency-history/ for more info.

`LATENCY LATEST` - Redis command function.
  Available since: Redis 2.8.13
       Complexity: O(1)

Returns the latest latency samples for all events.
Ref. https://redis.io/commands/latency-latest/ for more info.

`LATENCY RESET` - Redis command function.
  Available since: Redis 2.8.13
       Complexity: O(1)

Resets the latency data for one or more events.
Ref. https://redis.io/commands/latency-reset/ for more info.

`LCS` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(N*M) where N and M are the lengths of s1 and s2, respectively

Finds the longest common substring.
Ref. https://redis.io/commands/lcs/ for more info.

`LINDEX` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N) where N is the number of elements to traverse to get to the element at index. This makes asking for the first or the last element of the list O(1).

Returns an element from a list by its index.
Ref. https://redis.io/commands/lindex/ for more info.

`LINSERT` - Redis command function.
  Available since: Redis 2.2.0
       Complexity: O(N) where N is the number of elements to traverse before seeing the value pivot. This means that inserting somewhere on the left end on the list (head) can be considered O(1) and inserting somewhere on the right end (tail) is O(N).

Inserts an element before or after another element in a list.
Ref. https://redis.io/commands/linsert/ for more info.

`LLEN` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Returns the length of a list.
Ref. https://redis.io/commands/llen/ for more info.

`LMOVE` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(1)

Returns an element after popping it from one list and pushing it to another. Deletes the list if the last element was moved.
Ref. https://redis.io/commands/lmove/ for more info.

`LMPOP` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(N+M) where N is the number of provided keys and M is the number of elements returned.

Returns multiple elements from a list after removing them. Deletes the list if the last element was popped.
Ref. https://redis.io/commands/lmpop/ for more info.

`LOLWUT` - Redis command function.
  Available since: Redis 5.0.0

Displays computer art and the Redis version
Ref. https://redis.io/commands/lolwut/ for more info.

`LPOP` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N) where N is the number of elements returned

Returns the first elements in a list after removing it. Deletes the list if the last element was popped.
Ref. https://redis.io/commands/lpop/ for more info.

`LPOS` - Redis command function.
  Available since: Redis 6.0.6
       Complexity: O(N) where N is the number of elements in the list, for the average case. When searching for elements near the head or the tail of the list, or when the MAXLEN option is provided, the command may run in constant time.

Returns the index of matching elements in a list.
Ref. https://redis.io/commands/lpos/ for more info.

`LPUSH` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.

Prepends one or more elements to a list. Creates the key if it doesn't exist.
Ref. https://redis.io/commands/lpush/ for more info.

`LPUSHX` - Redis command function.
  Available since: Redis 2.2.0
       Complexity: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.

Prepends one or more elements to a list only when the list exists.
Ref. https://redis.io/commands/lpushx/ for more info.

`LRANGE` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(S+N) where S is the distance of start offset from HEAD for small lists, from nearest end (HEAD or TAIL) for large lists; and N is the number of elements in the specified range.

Returns a range of elements from a list.
Ref. https://redis.io/commands/lrange/ for more info.

`LREM` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N+M) where N is the length of the list and M is the number of elements removed.

Removes elements from a list. Deletes the list if the last element was removed.
Ref. https://redis.io/commands/lrem/ for more info.

`LSET` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N) where N is the length of the list. Setting either the first or the last element of the list is O(1).

Sets the value of an element in a list by its index.
Ref. https://redis.io/commands/lset/ for more info.

`LTRIM` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N) where N is the number of elements to be removed by the operation.

Removes elements from both ends a list. Deletes the list if all elements were trimmed.
Ref. https://redis.io/commands/ltrim/ for more info.

All singing, all dancing Lua script helper. Like `eval*` but allows script
vars to be provided as {<var> <value> ...} maps:

(lua "redis.call('set', _:my-key, _:my-arg)" {:my-key "foo} {:my-arg "bar"})

Keys are separate from other args as an implementation detail for clustering
purposes (keys need to all be on same shard).

Alpha - subject to change.
Like `lua`, but optimized for the single-server, single-client case: maintains
set of Lua scripts previously loaded by this client and will _not_ speculate
on script availability. CANNOT be used in environments where Redis servers may
go down and come back up again independently of application servers (clients).

`MEMORY` - Redis command function.
  Available since: Redis 4.0.0
       Complexity: Depends on subcommand.

A container for memory diagnostics commands.
Ref. https://redis.io/commands/memory/ for more info.

`MEMORY DOCTOR` - Redis command function.
  Available since: Redis 4.0.0
       Complexity: O(1)

Outputs a memory problems report.
Ref. https://redis.io/commands/memory-doctor/ for more info.

`MEMORY HELP` - Redis command function.
  Available since: Redis 4.0.0
       Complexity: O(1)

Returns helpful text about the different subcommands.
Ref. https://redis.io/commands/memory-help/ for more info.

`MEMORY MALLOC-STATS` - Redis command function.
  Available since: Redis 4.0.0
       Complexity: Depends on how much memory is allocated, could be slow

Returns the allocator statistics.
Ref. https://redis.io/commands/memory-malloc-stats/ for more info.

`MEMORY PURGE` - Redis command function.
  Available since: Redis 4.0.0
       Complexity: Depends on how much memory is allocated, could be slow

Asks the allocator to release memory.
Ref. https://redis.io/commands/memory-purge/ for more info.

`MEMORY STATS` - Redis command function.
  Available since: Redis 4.0.0
       Complexity: O(1)

Returns details about memory usage.
Ref. https://redis.io/commands/memory-stats/ for more info.

`MEMORY USAGE` - Redis command function.
  Available since: Redis 4.0.0
       Complexity: O(N) where N is the number of samples.

Estimates the memory usage of a key.
Ref. https://redis.io/commands/memory-usage/ for more info.

`MGET` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N) where N is the number of keys to retrieve.

Atomically returns the string values of one or more keys.
Ref. https://redis.io/commands/mget/ for more info.

`MIGRATE` - Redis command function.
  Available since: Redis 2.6.0
       Complexity: This command actually executes a DUMP+DEL in the source instance, and a RESTORE in the target instance. See the pages of these commands for time complexity. Also an O(N) data transfer between the two instances is performed.

Atomically transfers a key from one Redis instance to another.
Ref. https://redis.io/commands/migrate/ for more info.

`MODULE` - Redis command function.
  Available since: Redis 4.0.0
       Complexity: Depends on subcommand.

A container for module commands.
Ref. https://redis.io/commands/module/ for more info.

`MODULE HELP` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(1)

Returns helpful text about the different subcommands.
Ref. https://redis.io/commands/module-help/ for more info.

`MODULE LIST` - Redis command function.
  Available since: Redis 4.0.0
       Complexity: O(N) where N is the number of loaded modules.

Returns all loaded modules.
Ref. https://redis.io/commands/module-list/ for more info.

`MODULE LOAD` - Redis command function.
  Available since: Redis 4.0.0
       Complexity: O(1)

Loads a module.
Ref. https://redis.io/commands/module-load/ for more info.

`MODULE LOADEX` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(1)

Loads a module using extended parameters.
Ref. https://redis.io/commands/module-loadex/ for more info.

`MODULE UNLOAD` - Redis command function.
  Available since: Redis 4.0.0
       Complexity: O(1)

Unloads a module.
Ref. https://redis.io/commands/module-unload/ for more info.

`MONITOR` - Redis command function.
  Available since: Redis 1.0.0

Listens for all requests received by the server in real-time.
Ref. https://redis.io/commands/monitor/ for more info.

`MOVE` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Moves a key to another database.
Ref. https://redis.io/commands/move/ for more info.

`MSET` - Redis command function.
  Available since: Redis 1.0.1
       Complexity: O(N) where N is the number of keys to set.

Atomically creates or modifies the string values of one or more keys.
Ref. https://redis.io/commands/mset/ for more info.

`MSETNX` - Redis command function.
  Available since: Redis 1.0.1
       Complexity: O(N) where N is the number of keys to set.

Atomically modifies the string values of one or more keys only when all keys don't exist.
Ref. https://redis.io/commands/msetnx/ for more info.

`MULTI` - Redis command function.
  Available since: Redis 1.2.0
       Complexity: O(1)

Starts a transaction.
Ref. https://redis.io/commands/multi/ for more info.

`OBJECT` - Redis command function.
  Available since: Redis 2.2.3
       Complexity: Depends on subcommand.

A container for object introspection commands.
Ref. https://redis.io/commands/object/ for more info.

`OBJECT ENCODING` - Redis command function.
  Available since: Redis 2.2.3
       Complexity: O(1)

Returns the internal encoding of a Redis object.
Ref. https://redis.io/commands/object-encoding/ for more info.

`OBJECT FREQ` - Redis command function.
  Available since: Redis 4.0.0
       Complexity: O(1)

Returns the logarithmic access frequency counter of a Redis object.
Ref. https://redis.io/commands/object-freq/ for more info.

`OBJECT HELP` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(1)

Returns helpful text about the different subcommands.
Ref. https://redis.io/commands/object-help/ for more info.

`OBJECT IDLETIME` - Redis command function.
  Available since: Redis 2.2.3
       Complexity: O(1)

Returns the time since the last access to a Redis object.
Ref. https://redis.io/commands/object-idletime/ for more info.

`OBJECT REFCOUNT` - Redis command function.
  Available since: Redis 2.2.3
       Complexity: O(1)

Returns the reference count of a value of a key.
Ref. https://redis.io/commands/object-refcount/ for more info.

Wraps body so that replies to any wrapped Redis commands will be parsed with
`(f reply)`. Replaces any current parser; removes parser when `f` is nil.
See also `parser-comp`.

Parses given listener message of form:
  - ["pong"                              ""]
  - ["message"            <channel> <payload>]
  - ["pmessage" <pattern> <channel> <payload>], etc.

and returns {:kind _ :pattern _ :channel _ :payload _ :raw _}.

Composes parsers when f or g are nnil, preserving metadata

`PERSIST` - Redis command function.
  Available since: Redis 2.2.0
       Complexity: O(1)

Removes the expiration time of a key.
Ref. https://redis.io/commands/persist/ for more info.

`PEXPIRE` - Redis command function.
  Available since: Redis 2.6.0
       Complexity: O(1)

Sets the expiration time of a key in milliseconds.
Ref. https://redis.io/commands/pexpire/ for more info.

`PEXPIREAT` - Redis command function.
  Available since: Redis 2.6.0
       Complexity: O(1)

Sets the expiration time of a key to a Unix milliseconds timestamp.
Ref. https://redis.io/commands/pexpireat/ for more info.

`PEXPIRETIME` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(1)

Returns the expiration time of a key as a Unix milliseconds timestamp.
Ref. https://redis.io/commands/pexpiretime/ for more info.

`PFADD` - Redis command function.
  Available since: Redis 2.8.9
       Complexity: O(1) to add every element.

Adds elements to a HyperLogLog key. Creates the key if it doesn't exist.
Ref. https://redis.io/commands/pfadd/ for more info.

`PFCOUNT` - Redis command function.
  Available since: Redis 2.8.9
       Complexity: O(1) with a very small average constant time when called with a single key. O(N) with N being the number of keys, and much bigger constant times, when called with multiple keys.

Returns the approximated cardinality of the set(s) observed by the HyperLogLog key(s).
Ref. https://redis.io/commands/pfcount/ for more info.

`PFDEBUG` - Redis command function.
  Available since: Redis 2.8.9
       Complexity: N/A

Internal commands for debugging HyperLogLog values.
Ref. https://redis.io/commands/pfdebug/ for more info.

`PFMERGE` - Redis command function.
  Available since: Redis 2.8.9
       Complexity: O(N) to merge N HyperLogLogs, but with high constant times.

Merges one or more HyperLogLog values into a single key.
Ref. https://redis.io/commands/pfmerge/ for more info.

`PFSELFTEST` - Redis command function.
  Available since: Redis 2.8.9
       Complexity: N/A

An internal command for testing HyperLogLog values.
Ref. https://redis.io/commands/pfselftest/ for more info.

`PING` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Returns the server's liveliness response.
Ref. https://redis.io/commands/ping/ for more info.

`PSETEX` - Redis command function.
  Available since: Redis 2.6.0
       Complexity: O(1)

Sets both string value and expiration time in milliseconds of a key. The key is created if it doesn't exist.
Ref. https://redis.io/commands/psetex/ for more info.

`PSUBSCRIBE` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(N) where N is the number of patterns to subscribe to.

Listens for messages published to channels that match one or more patterns.
Ref. https://redis.io/commands/psubscribe/ for more info.

`PSYNC` - Redis command function.
  Available since: Redis 2.8.0

An internal command used in replication.
Ref. https://redis.io/commands/psync/ for more info.

`PTTL` - Redis command function.
  Available since: Redis 2.6.0
       Complexity: O(1)

Returns the expiration time in milliseconds of a key.
Ref. https://redis.io/commands/pttl/ for more info.

`PUBLISH` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(N+M) where N is the number of clients subscribed to the receiving channel and M is the total number of subscribed patterns (by any client).

Posts a message to a channel.
Ref. https://redis.io/commands/publish/ for more info.

`PUBSUB` - Redis command function.
  Available since: Redis 2.8.0
       Complexity: Depends on subcommand.

A container for Pub/Sub commands.
Ref. https://redis.io/commands/pubsub/ for more info.

`PUBSUB CHANNELS` - Redis command function.
  Available since: Redis 2.8.0
       Complexity: O(N) where N is the number of active channels, and assuming constant time pattern matching (relatively short channels and patterns)

Returns the active channels.
Ref. https://redis.io/commands/pubsub-channels/ for more info.

`PUBSUB HELP` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(1)

Returns helpful text about the different subcommands.
Ref. https://redis.io/commands/pubsub-help/ for more info.

`PUBSUB NUMPAT` - Redis command function.
  Available since: Redis 2.8.0
       Complexity: O(1)

Returns a count of unique pattern subscriptions.
Ref. https://redis.io/commands/pubsub-numpat/ for more info.

`PUBSUB NUMSUB` - Redis command function.
  Available since: Redis 2.8.0
       Complexity: O(N) for the NUMSUB subcommand, where N is the number of requested channels

Returns a count of subscribers to channels.
Ref. https://redis.io/commands/pubsub-numsub/ for more info.

`PUBSUB SHARDCHANNELS` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(N) where N is the number of active shard channels, and assuming constant time pattern matching (relatively short shard channels).

Returns the active shard channels.
Ref. https://redis.io/commands/pubsub-shardchannels/ for more info.

`PUBSUB SHARDNUMSUB` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(N) for the SHARDNUMSUB subcommand, where N is the number of requested shard channels

Returns the count of subscribers of shard channels.
Ref. https://redis.io/commands/pubsub-shardnumsub/ for more info.

`PUNSUBSCRIBE` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(N) where N is the number of patterns to unsubscribe.

Stops listening to messages published to channels that match one or more patterns.
Ref. https://redis.io/commands/punsubscribe/ for more info.

`QUIT` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Closes the connection.
Ref. https://redis.io/commands/quit/ for more info.

`RANDOMKEY` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Returns a random key name from the database.
Ref. https://redis.io/commands/randomkey/ for more info.

Forces byte[] argument to be sent to Redis as raw, unencoded bytes.

`READONLY` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(1)

Enables read-only queries for a connection to a Redis Cluster replica node.
Ref. https://redis.io/commands/readonly/ for more info.

`READWRITE` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(1)

Enables read-write queries for a connection to a Reids Cluster replica node.
Ref. https://redis.io/commands/readwrite/ for more info.

Sends low-level requests to Redis. Useful for DSLs, certain kinds of command
composition, and for executing commands that haven't yet been added to the
official `commands.json` spec.

(redis-call ["set" "foo" "bar"] ["get" "foo"])

Experimental. Like `reduce-scan` but:
- `rf` is (fn [acc k v]), as in `reduce-kv`.
- `rf` will never be called with the same key twice
  (i.e. automatically de-duplicates elements).

For use with `scan`, `hscan`, `zscan`, etc. Takes:
- (fn rf      [acc scan-result]) -> next accumulator
- (fn scan-fn [cursor]) -> next scan result

`RENAME` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Renames a key and overwrites the destination.
Ref. https://redis.io/commands/rename/ for more info.

`RENAMENX` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Renames a key only when the target key name doesn't exist.
Ref. https://redis.io/commands/renamenx/ for more info.

`REPLCONF` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(1)

An internal command for configuring the replication stream.
Ref. https://redis.io/commands/replconf/ for more info.

`REPLICAOF` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(1)

Configures a server as replica of another, or promotes it to a master.
Ref. https://redis.io/commands/replicaof/ for more info.

`RESET` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(1)

Resets the connection.
Ref. https://redis.io/commands/reset/ for more info.

`RESTORE` - Redis command function.
  Available since: Redis 2.6.0
       Complexity: O(1) to create the new key and additional O(N*M) to reconstruct the serialized value, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1*M) where M is small, so simply O(1). However for sorted set values the complexity is O(N*M*log(N)) because inserting values into sorted sets is O(log(N)).

Creates a key from the serialized representation of a value.
Ref. https://redis.io/commands/restore/ for more info.

`RESTORE-ASKING` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(1) to create the new key and additional O(N*M) to reconstruct the serialized value, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1*M) where M is small, so simply O(1). However for sorted set values the complexity is O(N*M*log(N)) because inserting values into sorted sets is O(log(N)).

An internal command for migrating keys in a cluster.
Ref. https://redis.io/commands/restore-asking/ for more info.

Takes values and returns them as part of next reply from Redis server.
Unlike `echo`, does not actually send any data to Redis.

`ROLE` - Redis command function.
  Available since: Redis 2.8.12
       Complexity: O(1)

Returns the replication role.
Ref. https://redis.io/commands/role/ for more info.

`RPOP` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N) where N is the number of elements returned

Returns and removes the last elements of a list. Deletes the list if the last element was popped.
Ref. https://redis.io/commands/rpop/ for more info.

`RPOPLPUSH` - Redis command function.
  Available since: Redis 1.2.0
       Complexity: O(1)

Returns the last element of a list after removing and pushing it to another list. Deletes the list if the last element was popped.
Ref. https://redis.io/commands/rpoplpush/ for more info.

`RPUSH` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.

Appends one or more elements to a list. Creates the key if it doesn't exist.
Ref. https://redis.io/commands/rpush/ for more info.

`RPUSHX` - Redis command function.
  Available since: Redis 2.2.0
       Complexity: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.

Appends an element to a list only when the list exists.
Ref. https://redis.io/commands/rpushx/ for more info.

`SADD` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.

Adds one or more members to a set. Creates the key if it doesn't exist.
Ref. https://redis.io/commands/sadd/ for more info.

`SAVE` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N) where N is the total number of keys in all databases

Synchronously saves the database(s) to disk.
Ref. https://redis.io/commands/save/ for more info.

`SCAN` - Redis command function.
  Available since: Redis 2.8.0
       Complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection.

Iterates over the key names in the database.
Ref. https://redis.io/commands/scan/ for more info.

Returns a set of Redis keys that match the given pattern.
Like the Redis `keys` command, but implemented using `scan` so safe to
use in production.

  (scan-keys <conn-opts> "*")     => Set of all keys
  (scan-keys <conn-opts> "foo:*") => Set of all keys starting with "foo:"

`SCARD` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Returns the number of members in a set.
Ref. https://redis.io/commands/scard/ for more info.

`SCRIPT` - Redis command function.
  Available since: Redis 2.6.0
       Complexity: Depends on subcommand.

A container for Lua scripts management commands.
Ref. https://redis.io/commands/script/ for more info.

`SCRIPT DEBUG` - Redis command function.
  Available since: Redis 3.2.0
       Complexity: O(1)

Sets the debug mode of server-side Lua scripts.
Ref. https://redis.io/commands/script-debug/ for more info.

`SCRIPT EXISTS` - Redis command function.
  Available since: Redis 2.6.0
       Complexity: O(N) with N being the number of scripts to check (so checking a single script is an O(1) operation).

Determines whether server-side Lua scripts exist in the script cache.
Ref. https://redis.io/commands/script-exists/ for more info.

`SCRIPT FLUSH` - Redis command function.
  Available since: Redis 2.6.0
       Complexity: O(N) with N being the number of scripts in cache

Removes all server-side Lua scripts from the script cache.
Ref. https://redis.io/commands/script-flush/ for more info.

`SCRIPT HELP` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(1)

Returns helpful text about the different subcommands.
Ref. https://redis.io/commands/script-help/ for more info.

`SCRIPT KILL` - Redis command function.
  Available since: Redis 2.6.0
       Complexity: O(1)

Terminates a server-side Lua script during execution.
Ref. https://redis.io/commands/script-kill/ for more info.

`SCRIPT LOAD` - Redis command function.
  Available since: Redis 2.6.0
       Complexity: O(N) with N being the length in bytes of the script body.

Loads a server-side Lua script to the script cache.
Ref. https://redis.io/commands/script-load/ for more info.

`SDIFF` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N) where N is the total number of elements in all given sets.

Returns the difference of multiple sets.
Ref. https://redis.io/commands/sdiff/ for more info.

`SDIFFSTORE` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N) where N is the total number of elements in all given sets.

Stores the difference of multiple sets in a key.
Ref. https://redis.io/commands/sdiffstore/ for more info.

`SELECT` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Changes the selected database.
Ref. https://redis.io/commands/select/ for more info.

`SET` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Sets the string value of a key, ignoring its type. The key is created if it doesn't exist.
Ref. https://redis.io/commands/set/ for more info.

Sets Timbre's minimum log level for internal Carmine namespaces.
Possible levels: #{:trace :debug :info :warn :error :fatal :report}.
Default level: `:warn`.

`SETBIT` - Redis command function.
  Available since: Redis 2.2.0
       Complexity: O(1)

Sets or clears the bit at offset of the string value. Creates the key if it doesn't exist.
Ref. https://redis.io/commands/setbit/ for more info.

`SETEX` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(1)

Sets the string value and expiration time of a key. Creates the key if it doesn't exist.
Ref. https://redis.io/commands/setex/ for more info.

`SETNX` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Set the string value of a key only when the key doesn't exist.
Ref. https://redis.io/commands/setnx/ for more info.

`SETRANGE` - Redis command function.
  Available since: Redis 2.2.0
       Complexity: O(1), not counting the time taken to copy the new string in place. Usually, this string is very small so the amortized complexity is O(1). Otherwise, complexity is O(M) with M being the length of the value argument.

Overwrites a part of a string value with another by an offset. Creates the key if it doesn't exist.
Ref. https://redis.io/commands/setrange/ for more info.

`SHUTDOWN` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N) when saving, where N is the total number of keys in all databases when saving data, otherwise O(1)

Synchronously saves the database(s) to disk and shuts down the Redis server.
Ref. https://redis.io/commands/shutdown/ for more info.

`SINTER` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.

Returns the intersect of multiple sets.
Ref. https://redis.io/commands/sinter/ for more info.

`SINTERCARD` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.

Returns the number of members of the intersect of multiple sets.
Ref. https://redis.io/commands/sintercard/ for more info.

`SINTERSTORE` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.

Stores the intersect of multiple sets in a key.
Ref. https://redis.io/commands/sinterstore/ for more info.

`SISMEMBER` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Determines whether a member belongs to a set.
Ref. https://redis.io/commands/sismember/ for more info.

`SLAVEOF` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Sets a Redis server as a replica of another, or promotes it to being a master.
Ref. https://redis.io/commands/slaveof/ for more info.

`SLOWLOG` - Redis command function.
  Available since: Redis 2.2.12
       Complexity: Depends on subcommand.

A container for slow log commands.
Ref. https://redis.io/commands/slowlog/ for more info.

`SLOWLOG GET` - Redis command function.
  Available since: Redis 2.2.12
       Complexity: O(N) where N is the number of entries returned

Returns the slow log's entries.
Ref. https://redis.io/commands/slowlog-get/ for more info.

`SLOWLOG HELP` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(1)

Show helpful text about the different subcommands
Ref. https://redis.io/commands/slowlog-help/ for more info.

`SLOWLOG LEN` - Redis command function.
  Available since: Redis 2.2.12
       Complexity: O(1)

Returns the number of entries in the slow log.
Ref. https://redis.io/commands/slowlog-len/ for more info.

`SLOWLOG RESET` - Redis command function.
  Available since: Redis 2.2.12
       Complexity: O(N) where N is the number of entries in the slowlog

Clears all entries from the slow log.
Ref. https://redis.io/commands/slowlog-reset/ for more info.

`SMEMBERS` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N) where N is the set cardinality.

Returns all members of a set.
Ref. https://redis.io/commands/smembers/ for more info.

`SMISMEMBER` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(N) where N is the number of elements being checked for membership

Determines whether multiple members belong to a set.
Ref. https://redis.io/commands/smismember/ for more info.

`SMOVE` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Moves a member from one set to another.
Ref. https://redis.io/commands/smove/ for more info.

`SORT` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N+M*log(M)) where N is the number of elements in the list or set to sort, and M the number of returned elements. When the elements are not sorted, complexity is O(N).

Sorts the elements in a list, a set, or a sorted set, optionally storing the result.
Ref. https://redis.io/commands/sort/ for more info.

Like `sort` but supports idiomatic Clojure arguments: :by pattern,
:limit offset count, :get pattern, :mget patterns, :store destination,
:alpha, :asc, :desc.

`SORT_RO` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(N+M*log(M)) where N is the number of elements in the list or set to sort, and M the number of returned elements. When the elements are not sorted, complexity is O(N).

Returns the sorted elements of a list, a set, or a sorted set.
Ref. https://redis.io/commands/sort_ro/ for more info.

`SPOP` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: Without the count argument O(1), otherwise O(N) where N is the value of the passed count.

Returns one or more random members from a set after removing them. Deletes the set if the last member was popped.
Ref. https://redis.io/commands/spop/ for more info.

`SPUBLISH` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(N) where N is the number of clients subscribed to the receiving shard channel.

Post a message to a shard channel
Ref. https://redis.io/commands/spublish/ for more info.

`SRANDMEMBER` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: Without the count argument O(1), otherwise O(N) where N is the absolute value of the passed count.

Get one or multiple random members from a set
Ref. https://redis.io/commands/srandmember/ for more info.

`SREM` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N) where N is the number of members to be removed.

Removes one or more members from a set. Deletes the set if the last member was removed.
Ref. https://redis.io/commands/srem/ for more info.

`SSCAN` - Redis command function.
  Available since: Redis 2.8.0
       Complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection.

Iterates over members of a set.
Ref. https://redis.io/commands/sscan/ for more info.

`SSUBSCRIBE` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(N) where N is the number of shard channels to subscribe to.

Listens for messages published to shard channels.
Ref. https://redis.io/commands/ssubscribe/ for more info.

`STRLEN` - Redis command function.
  Available since: Redis 2.2.0
       Complexity: O(1)

Returns the length of a string value.
Ref. https://redis.io/commands/strlen/ for more info.

`SUBSCRIBE` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(N) where N is the number of channels to subscribe to.

Listens for messages published to channels.
Ref. https://redis.io/commands/subscribe/ for more info.

`SUBSTR` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N) where N is the length of the returned string. The complexity is ultimately determined by the returned length, but because creating a substring from an existing string is very cheap, it can be considered O(1) for small strings.

Returns a substring from a string value.
Ref. https://redis.io/commands/substr/ for more info.

`SUNION` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N) where N is the total number of elements in all given sets.

Returns the union of multiple sets.
Ref. https://redis.io/commands/sunion/ for more info.

`SUNIONSTORE` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(N) where N is the total number of elements in all given sets.

Stores the union of multiple sets in a key.
Ref. https://redis.io/commands/sunionstore/ for more info.

`SUNSUBSCRIBE` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(N) where N is the number of shard channels to unsubscribe.

Stops listening to messages posted to shard channels.
Ref. https://redis.io/commands/sunsubscribe/ for more info.

Experimental.

`SWAPDB` - Redis command function.
  Available since: Redis 4.0.0
       Complexity: O(N) where N is the count of clients watching or blocking on keys from both databases.

Swaps two Redis databases.
Ref. https://redis.io/commands/swapdb/ for more info.

`SYNC` - Redis command function.
  Available since: Redis 1.0.0

An internal command used in replication.
Ref. https://redis.io/commands/sync/ for more info.

If given agrgument is a byte-array starting with apparent NPY header,
calls `nippy/thaw` against argument, otherwise passes it through.

This util can be useful if you're manually disabling
`issue-83-workaround` but still have some cases where you're possibly
trying to read data affected by that issue.

NB does not trap thaw exceptions.
See `issue-83-workaround` for more info.

`TIME` - Redis command function.
  Available since: Redis 2.6.0
       Complexity: O(1)

Returns the server time.
Ref. https://redis.io/commands/time/ for more info.

`TOUCH` - Redis command function.
  Available since: Redis 3.2.1
       Complexity: O(N) where N is the number of keys that will be touched.

Returns the number of existing keys out of those specified after updating the time they were last accessed.
Ref. https://redis.io/commands/touch/ for more info.

`TTL` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Returns the expiration time in seconds of a key.
Ref. https://redis.io/commands/ttl/ for more info.

`TYPE` - Redis command function.
  Available since: Redis 1.0.0
       Complexity: O(1)

Determines the type of value stored at a key.
Ref. https://redis.io/commands/type/ for more info.

`UNLINK` - Redis command function.
  Available since: Redis 4.0.0
       Complexity: O(1) for each key removed regardless of its size. Then the command does O(N) work in a different thread in order to reclaim memory, where N is the number of allocations the deleted objects where composed of.

Asynchronously deletes one or more keys.
Ref. https://redis.io/commands/unlink/ for more info.

`UNSUBSCRIBE` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(N) where N is the number of channels to unsubscribe.

Stops listening to messages posted to channels.
Ref. https://redis.io/commands/unsubscribe/ for more info.

`UNWATCH` - Redis command function.
  Available since: Redis 2.2.0
       Complexity: O(1)

Forgets about watched keys of a transaction.
Ref. https://redis.io/commands/unwatch/ for more info.

`WAIT` - Redis command function.
  Available since: Redis 3.0.0
       Complexity: O(1)

Blocks until the asynchronous replication of all preceding write commands sent by the connection is completed.
Ref. https://redis.io/commands/wait/ for more info.

`WAITAOF` - Redis command function.
  Available since: Redis 7.2.0
       Complexity: O(1)

Blocks until all of the preceding write commands sent by the connection are written to the append-only file of the master and/or replicas.
Ref. https://redis.io/commands/waitaof/ for more info.

`WATCH` - Redis command function.
  Available since: Redis 2.2.0
       Complexity: O(1) for every key.

Monitors changes to keys to determine the execution of a transaction.
Ref. https://redis.io/commands/watch/ for more info.

Main entry-point for the Carmine API.
Does the following:
  1. Establishes a connection to specified Redis server.
  2. Sends any Redis commands in body to the server as a pipeline.
  3. Reads and returns the server's reply.
  4. Destroys the connection, or returns it to connection pool.

`conn-opts` arg is a map of `:spec`, `:pool` keys.

  `spec` describes the connection details, e.g.:
    - {:host "127.0.0.1" :port 6379} ; Default
    - {:uri "redis://username:password@host.foo.com:9475/3" ; /3 for db 3
    - {:host "127.0.0.1"
       :port 6379
       :ssl-fn :default ; [1]
       :username "alice"
       :password "secret"
       :timeout-ms 6000
       :db 3}

  `pool` may be:
    - The `:none` keyword (=> don't pool connections)
    - A custom pool you've created manually with `connection-pool`
    - A map of pool-opts as provided to `connection-pool` (a pool
      will be automatically created, then reused on subsequent
      calls with the same opts)

    If no `pool` value is specified, a default pool will be created
    then reused.

Note that because of thread-binding, you'll probably want to avoid lazy
Redis commands in `wcar`'s body. Compare:
  `(wcar {} (for   [k [:k1 :k2]] (car/set k :val))` ; Lazy,  0 commands run
  `(wcar {} (doseq [k [:k1 :k2]] (car/set k :val))` ; Eager, 2 commands run

See also `connection-pool`, `with-replies`.

[1] Optional `ssl-fn` conn opt takes and returns a `java.net.Socket`:
  (fn [{:keys [^Socket socket host port]}]) -> ^Socket
  `:default` => use `taoensso.carmine.connections/default-ssl-fn`.

Creates a persistent[1] connection to Redis server and a future to listen for
server messages on that connection.

(fn handler [msg current-state]) will be called on each incoming message [2].

Evaluates body within the context of the connection and returns a
general-purpose Listener containing:

  1. The connection for use with `with-open-listener`, `close-listener`.
  2. An atom containing the handler fn.
  3. An atom containing optional listener state.

Useful for Pub/Sub, monitoring, etc.

Errors will be published to "carmine:listener:error" channel with Clojure
payload {:keys [error throwable listener]},
  :error e/o #{:conn-closed :conn-broken :handler-ex}.

[1] You probably do *NOT* want a :timeout for your `conn-spec` here.
`conn-spec` can include `:ping-ms`, which'll test conn every given msecs.
0
[2] See also `parse-listener-msg`.

Like `with-new-listener` but `handler` is:
{<channel-or-pattern> (fn handler [msg])}.

Example:

  (with-new-pubsub-listener
    {} ; Connection spec, as per `wcar` docstring [1]

    {"channel1" (fn [msg] (println "Channel match: " msg))
     "user*"    (fn [msg] (println "Pattern match: " msg))}

    (subscribe "foobar") ; Subscribe thread conn to "foobar" channel
    (psubscribe "foo*")  ; Subscribe thread conn to "foo*"   channel pattern
    )

See `with-new-listener` for more info.

Evaluates body within the context of given listener's pre-existing persistent
connection.

Alpha - subject to change.
Evaluates body, immediately returning the server's response to any
contained Redis commands (i.e. before enclosing context ends).

As an implementation detail, stashes and then `return`s any replies already
queued with Redis server: i.e. should be compatible with pipelining.

Note on parsers: if you're writing a Redis command (e.g. a fn that is
intended to execute w/in an implicit connection context) and you're using
`with-replies` as an implementation detail (i.e. you're interpreting
replies internally), you probably want `(parse nil (with-replies ...))` to
keep external parsers from leaking into your internal logic.

`XACK` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(1) for each message ID processed.

Returns the number of messages that were successfully acknowledged by the consumer group member of a stream.
Ref. https://redis.io/commands/xack/ for more info.

`XADD` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(1) when adding a new entry, O(N) when trimming where N being the number of entries evicted.

Appends a new message to a stream. Creates the key if it doesn't exist.
Ref. https://redis.io/commands/xadd/ for more info.

`XAUTOCLAIM` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(1) if COUNT is small.

Changes, or acquires, ownership of messages in a consumer group, as if the messages were delivered to as consumer group member.
Ref. https://redis.io/commands/xautoclaim/ for more info.

`XCLAIM` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(log N) with N being the number of messages in the PEL of the consumer group.

Changes, or acquires, ownership of a message in a consumer group, as if the message was delivered a consumer group member.
Ref. https://redis.io/commands/xclaim/ for more info.

`XDEL` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(1) for each single item to delete in the stream, regardless of the stream size.

Returns the number of messages after removing them from a stream.
Ref. https://redis.io/commands/xdel/ for more info.

`XGROUP` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: Depends on subcommand.

A container for consumer groups commands.
Ref. https://redis.io/commands/xgroup/ for more info.

`XGROUP CREATE` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(1)

Creates a consumer group.
Ref. https://redis.io/commands/xgroup-create/ for more info.

`XGROUP CREATECONSUMER` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(1)

Creates a consumer in a consumer group.
Ref. https://redis.io/commands/xgroup-createconsumer/ for more info.

`XGROUP DELCONSUMER` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(1)

Deletes a consumer from a consumer group.
Ref. https://redis.io/commands/xgroup-delconsumer/ for more info.

`XGROUP DESTROY` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(N) where N is the number of entries in the group's pending entries list (PEL).

Destroys a consumer group.
Ref. https://redis.io/commands/xgroup-destroy/ for more info.

`XGROUP HELP` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(1)

Returns helpful text about the different subcommands.
Ref. https://redis.io/commands/xgroup-help/ for more info.

`XGROUP SETID` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(1)

Sets the last-delivered ID of a consumer group.
Ref. https://redis.io/commands/xgroup-setid/ for more info.

`XINFO` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: Depends on subcommand.

A container for stream introspection commands.
Ref. https://redis.io/commands/xinfo/ for more info.

`XINFO CONSUMERS` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(1)

Returns a list of the consumers in a consumer group.
Ref. https://redis.io/commands/xinfo-consumers/ for more info.

`XINFO GROUPS` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(1)

Returns a list of the consumer groups of a stream.
Ref. https://redis.io/commands/xinfo-groups/ for more info.

`XINFO HELP` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(1)

Returns helpful text about the different subcommands.
Ref. https://redis.io/commands/xinfo-help/ for more info.

`XINFO STREAM` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(1)

Returns information about a stream.
Ref. https://redis.io/commands/xinfo-stream/ for more info.

`XLEN` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(1)

Return the number of messages in a stream.
Ref. https://redis.io/commands/xlen/ for more info.

`XPENDING` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(N) with N being the number of elements returned, so asking for a small fixed number of entries per call is O(1). O(M), where M is the total number of entries scanned when used with the IDLE filter. When the command returns just the summary and the list of consumers is small, it runs in O(1) time; otherwise, an additional O(N) time for iterating every consumer.

Returns the information and entries from a stream consumer group's pending entries list.
Ref. https://redis.io/commands/xpending/ for more info.

`XRANGE` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(N) with N being the number of elements being returned. If N is constant (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1).

Returns the messages from a stream within a range of IDs.
Ref. https://redis.io/commands/xrange/ for more info.

`XREAD` - Redis command function.
  Available since: Redis 5.0.0

Returns messages from multiple streams with IDs greater than the ones requested. Blocks until a message is available otherwise.
Ref. https://redis.io/commands/xread/ for more info.

`XREADGROUP` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: For each stream mentioned: O(M) with M being the number of elements returned. If M is constant (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1). On the other side when XREADGROUP blocks, XADD will pay the O(N) time in order to serve the N clients blocked on the stream getting new data.

Returns new or historical messages from a stream for a consumer in a group. Blocks until a message is available otherwise.
Ref. https://redis.io/commands/xreadgroup/ for more info.

`XREVRANGE` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(N) with N being the number of elements returned. If N is constant (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1).

Returns the messages from a stream within a range of IDs in reverse order.
Ref. https://redis.io/commands/xrevrange/ for more info.

`XSETID` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(1)

An internal command for replicating stream values.
Ref. https://redis.io/commands/xsetid/ for more info.

`XTRIM` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(N), with N being the number of evicted entries. Constant times are very small however, since entries are organized in macro nodes containing multiple entries that can be released with a single deallocation.

Deletes messages from the beginning of a stream.
Ref. https://redis.io/commands/xtrim/ for more info.

`ZADD` - Redis command function.
  Available since: Redis 1.2.0
       Complexity: O(log(N)) for each item added, where N is the number of elements in the sorted set.

Adds one or more members to a sorted set, or updates their scores. Creates the key if it doesn't exist.
Ref. https://redis.io/commands/zadd/ for more info.

`ZCARD` - Redis command function.
  Available since: Redis 1.2.0
       Complexity: O(1)

Returns the number of members in a sorted set.
Ref. https://redis.io/commands/zcard/ for more info.

`ZCOUNT` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(log(N)) with N being the number of elements in the sorted set.

Returns the count of members in a sorted set that have scores within a range.
Ref. https://redis.io/commands/zcount/ for more info.

`ZDIFF` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(L + (N-K)log(N)) worst case where L is the total number of elements in all the sets, N is the size of the first set, and K is the size of the result set.

Returns the difference between multiple sorted sets.
Ref. https://redis.io/commands/zdiff/ for more info.

`ZDIFFSTORE` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(L + (N-K)log(N)) worst case where L is the total number of elements in all the sets, N is the size of the first set, and K is the size of the result set.

Stores the difference of multiple sorted sets in a key.
Ref. https://redis.io/commands/zdiffstore/ for more info.

`ZINCRBY` - Redis command function.
  Available since: Redis 1.2.0
       Complexity: O(log(N)) where N is the number of elements in the sorted set.

Increments the score of a member in a sorted set.
Ref. https://redis.io/commands/zincrby/ for more info.

`ZINTER` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(N*K)+O(M*log(M)) worst case with N being the smallest input sorted set, K being the number of input sorted sets and M being the number of elements in the resulting sorted set.

Returns the intersect of multiple sorted sets.
Ref. https://redis.io/commands/zinter/ for more info.

`ZINTERCARD` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(N*K) worst case with N being the smallest input sorted set, K being the number of input sorted sets.

Returns the number of members of the intersect of multiple sorted sets.
Ref. https://redis.io/commands/zintercard/ for more info.

`ZINTERSTORE` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(N*K)+O(M*log(M)) worst case with N being the smallest input sorted set, K being the number of input sorted sets and M being the number of elements in the resulting sorted set.

Stores the intersect of multiple sorted sets in a key.
Ref. https://redis.io/commands/zinterstore/ for more info.

Like `zinterstore` but automatically counts keys.

`ZLEXCOUNT` - Redis command function.
  Available since: Redis 2.8.9
       Complexity: O(log(N)) with N being the number of elements in the sorted set.

Returns the number of members in a sorted set within a lexicographical range.
Ref. https://redis.io/commands/zlexcount/ for more info.

`ZMPOP` - Redis command function.
  Available since: Redis 7.0.0
       Complexity: O(K) + O(M*log(N)) where K is the number of provided keys, N being the number of elements in the sorted set, and M being the number of elements popped.

Returns the highest- or lowest-scoring members from one or more sorted sets after removing them. Deletes the sorted set if the last member was popped.
Ref. https://redis.io/commands/zmpop/ for more info.

`ZMSCORE` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(N) where N is the number of members being requested.

Returns the score of one or more members in a sorted set.
Ref. https://redis.io/commands/zmscore/ for more info.

`ZPOPMAX` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(log(N)*M) with N being the number of elements in the sorted set, and M being the number of elements popped.

Returns the highest-scoring members from a sorted set after removing them. Deletes the sorted set if the last member was popped.
Ref. https://redis.io/commands/zpopmax/ for more info.

`ZPOPMIN` - Redis command function.
  Available since: Redis 5.0.0
       Complexity: O(log(N)*M) with N being the number of elements in the sorted set, and M being the number of elements popped.

Returns the lowest-scoring members from a sorted set after removing them. Deletes the sorted set if the last member was popped.
Ref. https://redis.io/commands/zpopmin/ for more info.

`ZRANDMEMBER` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(N) where N is the number of members returned

Returns one or more random members from a sorted set.
Ref. https://redis.io/commands/zrandmember/ for more info.

`ZRANGE` - Redis command function.
  Available since: Redis 1.2.0
       Complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements returned.

Returns members in a sorted set within a range of indexes.
Ref. https://redis.io/commands/zrange/ for more info.

`ZRANGEBYLEX` - Redis command function.
  Available since: Redis 2.8.9
       Complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).

Returns members in a sorted set within a lexicographical range.
Ref. https://redis.io/commands/zrangebylex/ for more info.

`ZRANGEBYSCORE` - Redis command function.
  Available since: Redis 1.0.5
       Complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).

Returns members in a sorted set within a range of scores.
Ref. https://redis.io/commands/zrangebyscore/ for more info.

`ZRANGESTORE` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements stored into the destination key.

Stores a range of members from sorted set in a key.
Ref. https://redis.io/commands/zrangestore/ for more info.

`ZRANK` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(log(N))

Returns the index of a member in a sorted set ordered by ascending scores.
Ref. https://redis.io/commands/zrank/ for more info.

`ZREM` - Redis command function.
  Available since: Redis 1.2.0
       Complexity: O(M*log(N)) with N being the number of elements in the sorted set and M the number of elements to be removed.

Removes one or more members from a sorted set. Deletes the sorted set if all members were removed.
Ref. https://redis.io/commands/zrem/ for more info.

`ZREMRANGEBYLEX` - Redis command function.
  Available since: Redis 2.8.9
       Complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.

Removes members in a sorted set within a lexicographical range. Deletes the sorted set if all members were removed.
Ref. https://redis.io/commands/zremrangebylex/ for more info.

`ZREMRANGEBYRANK` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.

Removes members in a sorted set within a range of indexes. Deletes the sorted set if all members were removed.
Ref. https://redis.io/commands/zremrangebyrank/ for more info.

`ZREMRANGEBYSCORE` - Redis command function.
  Available since: Redis 1.2.0
       Complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.

Removes members in a sorted set within a range of scores. Deletes the sorted set if all members were removed.
Ref. https://redis.io/commands/zremrangebyscore/ for more info.

`ZREVRANGE` - Redis command function.
  Available since: Redis 1.2.0
       Complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements returned.

Returns members in a sorted set within a range of indexes in reverse order.
Ref. https://redis.io/commands/zrevrange/ for more info.

`ZREVRANGEBYLEX` - Redis command function.
  Available since: Redis 2.8.9
       Complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).

Returns members in a sorted set within a lexicographical range in reverse order.
Ref. https://redis.io/commands/zrevrangebylex/ for more info.

`ZREVRANGEBYSCORE` - Redis command function.
  Available since: Redis 2.2.0
       Complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).

Returns members in a sorted set within a range of scores in reverse order.
Ref. https://redis.io/commands/zrevrangebyscore/ for more info.

`ZREVRANK` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(log(N))

Returns the index of a member in a sorted set ordered by descending scores.
Ref. https://redis.io/commands/zrevrank/ for more info.

`ZSCAN` - Redis command function.
  Available since: Redis 2.8.0
       Complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection.

Iterates over members and scores of a sorted set.
Ref. https://redis.io/commands/zscan/ for more info.

`ZSCORE` - Redis command function.
  Available since: Redis 1.2.0
       Complexity: O(1)

Returns the score of a member in a sorted set.
Ref. https://redis.io/commands/zscore/ for more info.

`ZUNION` - Redis command function.
  Available since: Redis 6.2.0
       Complexity: O(N)+O(M*log(M)) with N being the sum of the sizes of the input sorted sets, and M being the number of elements in the resulting sorted set.

Returns the union of multiple sorted sets.
Ref. https://redis.io/commands/zunion/ for more info.

`ZUNIONSTORE` - Redis command function.
  Available since: Redis 2.0.0
       Complexity: O(N)+O(M log(M)) with N being the sum of the sizes of the input sorted sets, and M being the number of elements in the resulting sorted set.

Stores the union of multiple sorted sets in a key.
Ref. https://redis.io/commands/zunionstore/ for more info.

Like `zunionstore` but automatically counts keys.