acl-cat

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (acl-cat r)

is a wrapper around the acl cat Redis command.

It takes the same arguments as the Redis command.

acl-deluser

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (acl-deluser r username)

is a wrapper around the acl deluser Redis command.

It takes the same arguments as the Redis command.

acl-genpass

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (acl-genpass r)

is a wrapper around the acl genpass Redis command.

It takes the same arguments as the Redis command.

acl-getuser

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (acl-getuser r username)

is a wrapper around the acl getuser Redis command.

It takes the same arguments as the Redis command.

acl-list

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (acl-list r)

is a wrapper around the acl list Redis command.

It takes the same arguments as the Redis command.

acl-load

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (acl-load r)

is a wrapper around the acl load Redis command.

It takes the same arguments as the Redis command.

acl-log

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (acl-log r)

is a wrapper around the acl log Redis command.

It takes the same arguments as the Redis command.

acl-save

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (acl-save r)

is a wrapper around the acl save Redis command.

It takes the same arguments as the Redis command.

acl-setuser

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (acl-setuser r username rule)

is a wrapper around the acl setuser Redis command.

It takes the same arguments as the Redis command.

acl-users

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (acl-users r)

is a wrapper around the acl users Redis command.

It takes the same arguments as the Redis command.

acl-whoami

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (acl-whoami r)

is a wrapper around the acl whoami Redis command.

It takes the same arguments as the Redis command.

append

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (append r key value)

is a wrapper around the append Redis command.

It takes the same arguments as the Redis command.

auth

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (auth r password)

is a wrapper around the auth Redis command.

It takes the same arguments as the Redis command.

bgrewriteaof

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (bgrewriteaof r)

is a wrapper around the bgrewriteaof Redis command.

It takes the same arguments as the Redis command.

bgsave

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (bgsave r)

is a wrapper around the bgsave Redis command.

It takes the same arguments as the Redis command.

bitcount

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (bitcount r key)

is a wrapper around the bitcount Redis command.

It takes the same arguments as the Redis command.

bitfield

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (bitfield r key)

is a wrapper around the bitfield Redis command.

It takes the same arguments as the Redis command.

bitop

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (bitop r operation destkey key)

is a wrapper around the bitop Redis command.

It takes the same arguments as the Redis command.

bitpos

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (bitpos r key bit)

is a wrapper around the bitpos Redis command.

It takes the same arguments as the Redis command.

blmove

defn

(Fn [(Ref Redis a), b, c, d, e, f] (Result RESP String))

                        (blmove r source destination wherefrom whereto timeout)

is a wrapper around the blmove Redis command.

It takes the same arguments as the Redis command.

blmpop

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (blmpop r timeout numkeys key)

is a wrapper around the blmpop Redis command.

It takes the same arguments as the Redis command.

blpop

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (blpop r key timeout)

is a wrapper around the blpop Redis command.

It takes the same arguments as the Redis command.

brpop

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (brpop r key timeout)

is a wrapper around the brpop Redis command.

It takes the same arguments as the Redis command.

brpoplpush

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (brpoplpush r source destination timeout)

is a wrapper around the brpoplpush Redis command.

It takes the same arguments as the Redis command.

bzmpop

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (bzmpop r timeout numkeys key)

is a wrapper around the bzmpop Redis command.

It takes the same arguments as the Redis command.

bzpopmax

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (bzpopmax r key timeout)

is a wrapper around the bzpopmax Redis command.

It takes the same arguments as the Redis command.

bzpopmin

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (bzpopmin r key timeout)

is a wrapper around the bzpopmin Redis command.

It takes the same arguments as the Redis command.

client-caching

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (client-caching r mode)

is a wrapper around the client caching Redis command.

It takes the same arguments as the Redis command.

client-getname

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (client-getname r)

is a wrapper around the client getname Redis command.

It takes the same arguments as the Redis command.

client-getredir

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (client-getredir r)

is a wrapper around the client getredir Redis command.

It takes the same arguments as the Redis command.

client-id

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (client-id r)

is a wrapper around the client id Redis command.

It takes the same arguments as the Redis command.

client-kill

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (client-kill r)

is a wrapper around the client kill Redis command.

It takes the same arguments as the Redis command.

client-list

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (client-list r)

is a wrapper around the client list Redis command.

It takes the same arguments as the Redis command.

client-no-evict

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (client-no-evict r mode)

is a wrapper around the client no evict Redis command.

It takes the same arguments as the Redis command.

client-no-touch

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (client-no-touch r mode)

is a wrapper around the client no touch Redis command.

It takes the same arguments as the Redis command.

client-pause

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (client-pause r timeout)

is a wrapper around the client pause Redis command.

It takes the same arguments as the Redis command.

client-reply

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (client-reply r)

is a wrapper around the client reply Redis command.

It takes the same arguments as the Redis command.

client-setinfo

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (client-setinfo r attr value)

is a wrapper around the client setinfo Redis command.

It takes the same arguments as the Redis command.

client-setname

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (client-setname r connection-name)

is a wrapper around the client setname Redis command.

It takes the same arguments as the Redis command.

client-tracking

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (client-tracking r mode)

is a wrapper around the client tracking Redis command.

It takes the same arguments as the Redis command.

client-trackinginfo

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (client-trackinginfo r)

is a wrapper around the client trackinginfo Redis command.

It takes the same arguments as the Redis command.

client-unblock

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (client-unblock r client-id)

is a wrapper around the client unblock Redis command.

It takes the same arguments as the Redis command.

close

defn

(Fn [Redis] ())

                        (close r)

closes the connection to Redis.

cluster-addslots

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (cluster-addslots r slot)

is a wrapper around the cluster addslots Redis command.

It takes the same arguments as the Redis command.

cluster-addslotsrange

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (cluster-addslotsrange r slot)

is a wrapper around the cluster addslotsrange Redis command.

It takes the same arguments as the Redis command.

cluster-bumpepoch

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (cluster-bumpepoch r)

is a wrapper around the cluster bumpepoch Redis command.

It takes the same arguments as the Redis command.

cluster-count-failure-reports

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (cluster-count-failure-reports r node-id)

is a wrapper around the cluster count failure reports Redis command.

It takes the same arguments as the Redis command.

cluster-countkeysinslot

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (cluster-countkeysinslot r slot)

is a wrapper around the cluster countkeysinslot Redis command.

It takes the same arguments as the Redis command.

cluster-delslots

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (cluster-delslots r slot)

is a wrapper around the cluster delslots Redis command.

It takes the same arguments as the Redis command.

cluster-delslotsrange

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (cluster-delslotsrange r slot)

is a wrapper around the cluster delslotsrange Redis command.

It takes the same arguments as the Redis command.

cluster-failover

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (cluster-failover r)

is a wrapper around the cluster failover Redis command.

It takes the same arguments as the Redis command.

cluster-flushslots

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (cluster-flushslots r)

is a wrapper around the cluster flushslots Redis command.

It takes the same arguments as the Redis command.

cluster-forget

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (cluster-forget r node-id)

is a wrapper around the cluster forget Redis command.

It takes the same arguments as the Redis command.

cluster-getkeysinslot

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (cluster-getkeysinslot r slot count)

is a wrapper around the cluster getkeysinslot Redis command.

It takes the same arguments as the Redis command.

cluster-info

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (cluster-info r)

is a wrapper around the cluster info Redis command.

It takes the same arguments as the Redis command.

cluster-keyslot

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (cluster-keyslot r key)

is a wrapper around the cluster keyslot Redis command.

It takes the same arguments as the Redis command.

cluster-links

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (cluster-links r)

is a wrapper around the cluster links Redis command.

It takes the same arguments as the Redis command.

cluster-meet

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (cluster-meet r ip port)

is a wrapper around the cluster meet Redis command.

It takes the same arguments as the Redis command.

cluster-myid

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (cluster-myid r)

is a wrapper around the cluster myid Redis command.

It takes the same arguments as the Redis command.

cluster-nodes

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (cluster-nodes r)

is a wrapper around the cluster nodes Redis command.

It takes the same arguments as the Redis command.

cluster-replicas

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (cluster-replicas r node-id)

is a wrapper around the cluster replicas Redis command.

It takes the same arguments as the Redis command.

cluster-replicate

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (cluster-replicate r node-id)

is a wrapper around the cluster replicate Redis command.

It takes the same arguments as the Redis command.

cluster-reset

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (cluster-reset r)

is a wrapper around the cluster reset Redis command.

It takes the same arguments as the Redis command.

cluster-saveconfig

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (cluster-saveconfig r)

is a wrapper around the cluster saveconfig Redis command.

It takes the same arguments as the Redis command.

cluster-set-config-epoch

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (cluster-set-config-epoch r config-epoch)

is a wrapper around the cluster set config epoch Redis command.

It takes the same arguments as the Redis command.

cluster-setslot

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (cluster-setslot r slot)

is a wrapper around the cluster setslot Redis command.

It takes the same arguments as the Redis command.

cluster-shards

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (cluster-shards r)

is a wrapper around the cluster shards Redis command.

It takes the same arguments as the Redis command.

cluster-slaves

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (cluster-slaves r node-id)

is a wrapper around the cluster slaves Redis command.

It takes the same arguments as the Redis command.

cluster-slots

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (cluster-slots r)

is a wrapper around the cluster slots Redis command.

It takes the same arguments as the Redis command.

command

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (command r)

is a wrapper around the command Redis command.

It takes the same arguments as the Redis command.

command-count

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (command-count r)

is a wrapper around the command count Redis command.

It takes the same arguments as the Redis command.

command-docs

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (command-docs r command-name)

is a wrapper around the command docs Redis command.

It takes the same arguments as the Redis command.

command-getkeys

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (command-getkeys r)

is a wrapper around the command getkeys Redis command.

It takes the same arguments as the Redis command.

command-info

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (command-info r command-name)

is a wrapper around the command info Redis command.

It takes the same arguments as the Redis command.

command-list

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (command-list r)

is a wrapper around the command list Redis command.

It takes the same arguments as the Redis command.

config-get

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (config-get r parameter)

is a wrapper around the config get Redis command.

It takes the same arguments as the Redis command.

config-resetstat

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (config-resetstat r)

is a wrapper around the config resetstat Redis command.

It takes the same arguments as the Redis command.

config-rewrite

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (config-rewrite r)

is a wrapper around the config rewrite Redis command.

It takes the same arguments as the Redis command.

config-set

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (config-set r parameter value)

is a wrapper around the config set Redis command.

It takes the same arguments as the Redis command.

copy

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (copy r source destination)

is a wrapper around the copy Redis command.

It takes the same arguments as the Redis command.

dbsize

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (dbsize r)

is a wrapper around the dbsize Redis command.

It takes the same arguments as the Redis command.

debug-object

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (debug-object r key)

is a wrapper around the debug object Redis command.

It takes the same arguments as the Redis command.

debug-segfault

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (debug-segfault r)

is a wrapper around the debug segfault Redis command.

It takes the same arguments as the Redis command.

decr

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (decr r key)

is a wrapper around the decr Redis command.

It takes the same arguments as the Redis command.

decrby

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (decrby r key decrement)

is a wrapper around the decrby Redis command.

It takes the same arguments as the Redis command.

del

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (del r key)

is a wrapper around the del Redis command.

It takes the same arguments as the Redis command.

delete

instantiate

(Fn [Redis] ())

deletes a Redis. Should usually not be called manually.

discard

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (discard r)

is a wrapper around the discard Redis command.

It takes the same arguments as the Redis command.

dump

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (dump r key)

is a wrapper around the dump Redis command.

It takes the same arguments as the Redis command.

echo

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (echo r message)

is a wrapper around the echo Redis command.

It takes the same arguments as the Redis command.

eval

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (eval r script numkeys key)

is a wrapper around the eval Redis command.

It takes the same arguments as the Redis command.

eval_ro

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (eval_ro r script numkeys key)

is a wrapper around the eval_ro Redis command.

It takes the same arguments as the Redis command.

evalsha

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (evalsha r sha1 numkeys key)

is a wrapper around the evalsha Redis command.

It takes the same arguments as the Redis command.

evalsha_ro

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (evalsha_ro r sha1 numkeys key)

is a wrapper around the evalsha_ro Redis command.

It takes the same arguments as the Redis command.

exec

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (exec r)

is a wrapper around the exec Redis command.

It takes the same arguments as the Redis command.

exists

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (exists r key)

is a wrapper around the exists Redis command.

It takes the same arguments as the Redis command.

expire

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (expire r key seconds)

is a wrapper around the expire Redis command.

It takes the same arguments as the Redis command.

expireat

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (expireat r key timestamp)

is a wrapper around the expireat Redis command.

It takes the same arguments as the Redis command.

expiretime

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (expiretime r key)

is a wrapper around the expiretime Redis command.

It takes the same arguments as the Redis command.

fcall

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (fcall r function numkeys)

is a wrapper around the fcall Redis command.

It takes the same arguments as the Redis command.

fcall_ro

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (fcall_ro r function numkeys)

is a wrapper around the fcall_ro Redis command.

It takes the same arguments as the Redis command.

flushall

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (flushall r)

is a wrapper around the flushall Redis command.

It takes the same arguments as the Redis command.

flushdb

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (flushdb r)

is a wrapper around the flushdb Redis command.

It takes the same arguments as the Redis command.

function-delete

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (function-delete r library-name)

is a wrapper around the function delete Redis command.

It takes the same arguments as the Redis command.

function-dump

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (function-dump r)

is a wrapper around the function dump Redis command.

It takes the same arguments as the Redis command.

function-flush

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (function-flush r)

is a wrapper around the function flush Redis command.

It takes the same arguments as the Redis command.

function-list

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (function-list r)

is a wrapper around the function list Redis command.

It takes the same arguments as the Redis command.

function-load

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (function-load r library-code)

is a wrapper around the function load Redis command.

It takes the same arguments as the Redis command.

function-restore

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (function-restore r serialized-value)

is a wrapper around the function restore Redis command.

It takes the same arguments as the Redis command.

function-stats

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (function-stats r)

is a wrapper around the function stats Redis command.

It takes the same arguments as the Redis command.

geoadd

defn

(Fn [(Ref Redis a), b, c, d, e] (Result RESP String))

                        (geoadd r key longitude latitude member)

is a wrapper around the geoadd Redis command.

It takes the same arguments as the Redis command.

geodist

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (geodist r key member1 member2)

is a wrapper around the geodist Redis command.

It takes the same arguments as the Redis command.

geohash

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (geohash r key member)

is a wrapper around the geohash Redis command.

It takes the same arguments as the Redis command.

geopos

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (geopos r key member)

is a wrapper around the geopos Redis command.

It takes the same arguments as the Redis command.

georadius

defn

(Fn [(Ref Redis a), b, c, d, e] (Result RESP String))

                        (georadius r key longitude latitude radius)

is a wrapper around the georadius Redis command.

It takes the same arguments as the Redis command.

georadiusbymember

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (georadiusbymember r key member radius)

is a wrapper around the georadiusbymember Redis command.

It takes the same arguments as the Redis command.

geosearch

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (geosearch r key)

is a wrapper around the geosearch Redis command.

It takes the same arguments as the Redis command.

geosearchstore

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (geosearchstore r destination source)

is a wrapper around the geosearchstore Redis command.

It takes the same arguments as the Redis command.

get

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (get r key)

is a wrapper around the get Redis command.

It takes the same arguments as the Redis command.

getbit

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (getbit r key offset)

is a wrapper around the getbit Redis command.

It takes the same arguments as the Redis command.

getdel

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (getdel r key)

is a wrapper around the getdel Redis command.

It takes the same arguments as the Redis command.

getex

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (getex r key)

is a wrapper around the getex Redis command.

It takes the same arguments as the Redis command.

getrange

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (getrange r key start end)

is a wrapper around the getrange Redis command.

It takes the same arguments as the Redis command.

getset

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (getset r key value)

is a wrapper around the getset Redis command.

It takes the same arguments as the Redis command.

hdel

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (hdel r key field)

is a wrapper around the hdel Redis command.

It takes the same arguments as the Redis command.

hello

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (hello r)

is a wrapper around the hello Redis command.

It takes the same arguments as the Redis command.

hexists

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (hexists r key field)

is a wrapper around the hexists Redis command.

It takes the same arguments as the Redis command.

hget

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (hget r key field)

is a wrapper around the hget Redis command.

It takes the same arguments as the Redis command.

hgetall

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (hgetall r key)

is a wrapper around the hgetall Redis command.

It takes the same arguments as the Redis command.

hincrby

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (hincrby r key field increment)

is a wrapper around the hincrby Redis command.

It takes the same arguments as the Redis command.

hincrbyfloat

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (hincrbyfloat r key field increment)

is a wrapper around the hincrbyfloat Redis command.

It takes the same arguments as the Redis command.

hkeys

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (hkeys r key)

is a wrapper around the hkeys Redis command.

It takes the same arguments as the Redis command.

hlen

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (hlen r key)

is a wrapper around the hlen Redis command.

It takes the same arguments as the Redis command.

hmget

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (hmget r key field)

is a wrapper around the hmget Redis command.

It takes the same arguments as the Redis command.

hmset

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (hmset r key field value)

is a wrapper around the hmset Redis command.

It takes the same arguments as the Redis command.

hrandfield

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (hrandfield r key)

is a wrapper around the hrandfield Redis command.

It takes the same arguments as the Redis command.

hscan

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (hscan r key cursor)

is a wrapper around the hscan Redis command.

It takes the same arguments as the Redis command.

hset

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (hset r key field value)

is a wrapper around the hset Redis command.

It takes the same arguments as the Redis command.

hsetnx

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (hsetnx r key field value)

is a wrapper around the hsetnx Redis command.

It takes the same arguments as the Redis command.

hstrlen

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (hstrlen r key field)

is a wrapper around the hstrlen Redis command.

It takes the same arguments as the Redis command.

hvals

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (hvals r key)

is a wrapper around the hvals Redis command.

It takes the same arguments as the Redis command.

incr

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (incr r key)

is a wrapper around the incr Redis command.

It takes the same arguments as the Redis command.

incrby

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (incrby r key increment)

is a wrapper around the incrby Redis command.

It takes the same arguments as the Redis command.

incrbyfloat

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (incrbyfloat r key increment)

is a wrapper around the incrbyfloat Redis command.

It takes the same arguments as the Redis command.

info

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (info r)

is a wrapper around the info Redis command.

It takes the same arguments as the Redis command.

init

instantiate

(Fn [Socket] Redis)

creates a Redis.

keys

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (keys r pattern)

is a wrapper around the keys Redis command.

It takes the same arguments as the Redis command.

lastsave

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (lastsave r)

is a wrapper around the lastsave Redis command.

It takes the same arguments as the Redis command.

latency-doctor

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (latency-doctor r)

is a wrapper around the latency doctor Redis command.

It takes the same arguments as the Redis command.

latency-graph

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (latency-graph r event)

is a wrapper around the latency graph Redis command.

It takes the same arguments as the Redis command.

latency-help

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (latency-help r)

is a wrapper around the latency help Redis command.

It takes the same arguments as the Redis command.

latency-histogram

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (latency-histogram r)

is a wrapper around the latency histogram Redis command.

It takes the same arguments as the Redis command.

latency-history

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (latency-history r event)

is a wrapper around the latency history Redis command.

It takes the same arguments as the Redis command.

latency-latest

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (latency-latest r)

is a wrapper around the latency latest Redis command.

It takes the same arguments as the Redis command.

latency-reset

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (latency-reset r)

is a wrapper around the latency reset Redis command.

It takes the same arguments as the Redis command.

lcs

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (lcs r key1 key2)

is a wrapper around the lcs Redis command.

It takes the same arguments as the Redis command.

lindex

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (lindex r key index)

is a wrapper around the lindex Redis command.

It takes the same arguments as the Redis command.

linsert

defn

(Fn [(Ref Redis a), b, c, d, e] (Result RESP String))

                        (linsert r key w pivot element)

is a wrapper around the linsert Redis command.

It takes the same arguments as the Redis command.

llen

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (llen r key)

is a wrapper around the llen Redis command.

It takes the same arguments as the Redis command.

lmove

defn

(Fn [(Ref Redis a), b, c, d, e] (Result RESP String))

                        (lmove r source destination wherefrom whereto)

is a wrapper around the lmove Redis command.

It takes the same arguments as the Redis command.

lmpop

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (lmpop r numkeys key)

is a wrapper around the lmpop Redis command.

It takes the same arguments as the Redis command.

lolwut

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (lolwut r)

is a wrapper around the lolwut Redis command.

It takes the same arguments as the Redis command.

lpop

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (lpop r key)

is a wrapper around the lpop Redis command.

It takes the same arguments as the Redis command.

lpos

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (lpos r key element)

is a wrapper around the lpos Redis command.

It takes the same arguments as the Redis command.

lpush

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (lpush r key element)

is a wrapper around the lpush Redis command.

It takes the same arguments as the Redis command.

lpushx

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (lpushx r key element)

is a wrapper around the lpushx Redis command.

It takes the same arguments as the Redis command.

lrange

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (lrange r key start stop)

is a wrapper around the lrange Redis command.

It takes the same arguments as the Redis command.

lrem

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (lrem r key count element)

is a wrapper around the lrem Redis command.

It takes the same arguments as the Redis command.

lset

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (lset r key index element)

is a wrapper around the lset Redis command.

It takes the same arguments as the Redis command.

ltrim

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (ltrim r key start stop)

is a wrapper around the ltrim Redis command.

It takes the same arguments as the Redis command.

memory-doctor

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (memory-doctor r)

is a wrapper around the memory doctor Redis command.

It takes the same arguments as the Redis command.

memory-help

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (memory-help r)

is a wrapper around the memory help Redis command.

It takes the same arguments as the Redis command.

memory-malloc-stats

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (memory-malloc-stats r)

is a wrapper around the memory malloc stats Redis command.

It takes the same arguments as the Redis command.

memory-purge

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (memory-purge r)

is a wrapper around the memory purge Redis command.

It takes the same arguments as the Redis command.

memory-stats

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (memory-stats r)

is a wrapper around the memory stats Redis command.

It takes the same arguments as the Redis command.

memory-usage

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (memory-usage r key)

is a wrapper around the memory usage Redis command.

It takes the same arguments as the Redis command.

mget

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (mget r key)

is a wrapper around the mget Redis command.

It takes the same arguments as the Redis command.

migrate

defn

(Fn [(Ref Redis a), b, c, d, e, f] (Result RESP String))

                        (migrate r host port key destination-db timeout)

is a wrapper around the migrate Redis command.

It takes the same arguments as the Redis command.

module-list

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (module-list r)

is a wrapper around the module list Redis command.

It takes the same arguments as the Redis command.

module-load

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (module-load r path)

is a wrapper around the module load Redis command.

It takes the same arguments as the Redis command.

module-loadex

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (module-loadex r path)

is a wrapper around the module loadex Redis command.

It takes the same arguments as the Redis command.

module-unload

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (module-unload r name)

is a wrapper around the module unload Redis command.

It takes the same arguments as the Redis command.

monitor

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (monitor r)

is a wrapper around the monitor Redis command.

It takes the same arguments as the Redis command.

move

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (move r key db)

is a wrapper around the move Redis command.

It takes the same arguments as the Redis command.

mset

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (mset r key value)

is a wrapper around the mset Redis command.

It takes the same arguments as the Redis command.

msetnx

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (msetnx r key value)

is a wrapper around the msetnx Redis command.

It takes the same arguments as the Redis command.

multi

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (multi r)

is a wrapper around the multi Redis command.

It takes the same arguments as the Redis command.

object

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (object r subcommand)

is a wrapper around the object Redis command.

It takes the same arguments as the Redis command.

open

defn

(Fn [(Ref String a)] (Result Redis String))

                        (open host)

opens the connection to Redis on port 6379.

For variable port numbers please check out open-on.

open-on

defn

(Fn [(Ref String a), Int] (Result Redis String))

                        (open-on host port)

opens the connection to Redis on port port.

persist

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (persist r key)

is a wrapper around the persist Redis command.

It takes the same arguments as the Redis command.

pexpire

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (pexpire r key milliseconds)

is a wrapper around the pexpire Redis command.

It takes the same arguments as the Redis command.

pexpireat

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (pexpireat r key milliseconds-timestamp)

is a wrapper around the pexpireat Redis command.

It takes the same arguments as the Redis command.

pexpiretime

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (pexpiretime r key)

is a wrapper around the pexpiretime Redis command.

It takes the same arguments as the Redis command.

pfadd

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (pfadd r key element)

is a wrapper around the pfadd Redis command.

It takes the same arguments as the Redis command.

pfcount

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (pfcount r key)

is a wrapper around the pfcount Redis command.

It takes the same arguments as the Redis command.

pfmerge

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (pfmerge r destkey sourcekey)

is a wrapper around the pfmerge Redis command.

It takes the same arguments as the Redis command.

ping

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (ping r)

is a wrapper around the ping Redis command.

It takes the same arguments as the Redis command.

prn

instantiate

(Fn [(Ref Redis a)] String)

converts a Redis to a string.

psetex

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (psetex r key milliseconds value)

is a wrapper around the psetex Redis command.

It takes the same arguments as the Redis command.

psubscribe

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (psubscribe r pattern)

is a wrapper around the psubscribe Redis command.

It takes the same arguments as the Redis command.

psync

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (psync r replicationid offset)

is a wrapper around the psync Redis command.

It takes the same arguments as the Redis command.

pttl

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (pttl r key)

is a wrapper around the pttl Redis command.

It takes the same arguments as the Redis command.

publish

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (publish r channel message)

is a wrapper around the publish Redis command.

It takes the same arguments as the Redis command.

pubsub

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (pubsub r subcommand)

is a wrapper around the pubsub Redis command.

It takes the same arguments as the Redis command.

punsubscribe

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (punsubscribe r)

is a wrapper around the punsubscribe Redis command.

It takes the same arguments as the Redis command.

quit

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (quit r)

is a wrapper around the quit Redis command.

It takes the same arguments as the Redis command.

randomkey

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (randomkey r)

is a wrapper around the randomkey Redis command.

It takes the same arguments as the Redis command.

read

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (read r)

reads a RESP object from Redis.

readonly

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (readonly r)

is a wrapper around the readonly Redis command.

It takes the same arguments as the Redis command.

readwrite

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (readwrite r)

is a wrapper around the readwrite Redis command.

It takes the same arguments as the Redis command.

rename

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (rename r key newkey)

is a wrapper around the rename Redis command.

It takes the same arguments as the Redis command.

renamenx

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (renamenx r key newkey)

is a wrapper around the renamenx Redis command.

It takes the same arguments as the Redis command.

replicaof

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (replicaof r host port)

is a wrapper around the replicaof Redis command.

It takes the same arguments as the Redis command.

reset

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (reset r)

is a wrapper around the reset Redis command.

It takes the same arguments as the Redis command.

restore

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (restore r key ttl serialized-value)

is a wrapper around the restore Redis command.

It takes the same arguments as the Redis command.

role

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (role r)

is a wrapper around the role Redis command.

It takes the same arguments as the Redis command.

rpop

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (rpop r key)

is a wrapper around the rpop Redis command.

It takes the same arguments as the Redis command.

rpoplpush

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (rpoplpush r source destination)

is a wrapper around the rpoplpush Redis command.

It takes the same arguments as the Redis command.

rpush

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (rpush r key element)

is a wrapper around the rpush Redis command.

It takes the same arguments as the Redis command.

rpushx

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (rpushx r key element)

is a wrapper around the rpushx Redis command.

It takes the same arguments as the Redis command.

sadd

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (sadd r key member)

is a wrapper around the sadd Redis command.

It takes the same arguments as the Redis command.

save

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (save r)

is a wrapper around the save Redis command.

It takes the same arguments as the Redis command.

scan

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (scan r cursor)

is a wrapper around the scan Redis command.

It takes the same arguments as the Redis command.

scard

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (scard r key)

is a wrapper around the scard Redis command.

It takes the same arguments as the Redis command.

script-debug

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (script-debug r mode)

is a wrapper around the script debug Redis command.

It takes the same arguments as the Redis command.

script-exists

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (script-exists r sha1)

is a wrapper around the script exists Redis command.

It takes the same arguments as the Redis command.

script-flush

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (script-flush r)

is a wrapper around the script flush Redis command.

It takes the same arguments as the Redis command.

script-kill

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (script-kill r)

is a wrapper around the script kill Redis command.

It takes the same arguments as the Redis command.

script-load

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (script-load r script)

is a wrapper around the script load Redis command.

It takes the same arguments as the Redis command.

sdiff

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (sdiff r key)

is a wrapper around the sdiff Redis command.

It takes the same arguments as the Redis command.

sdiffstore

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (sdiffstore r destination key)

is a wrapper around the sdiffstore Redis command.

It takes the same arguments as the Redis command.

select

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (select r index)

is a wrapper around the select Redis command.

It takes the same arguments as the Redis command.

send

defn

(Fn [(Ref Redis a), String, (Ref (Array RESP) b)] ())

                        (send r cmd args)

sends the command cmd with the arguments args to Redis.

set

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (set r key value)

is a wrapper around the set Redis command.

It takes the same arguments as the Redis command.

set-sock

instantiate

(Fn [Redis, Socket] Redis)

sets the sock property of a Redis.

set-sock!

instantiate

(Fn [(Ref Redis a), Socket] ())

sets the sock property of a Redis in place.

setbit

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (setbit r key offset value)

is a wrapper around the setbit Redis command.

It takes the same arguments as the Redis command.

setex

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (setex r key seconds value)

is a wrapper around the setex Redis command.

It takes the same arguments as the Redis command.

setnx

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (setnx r key value)

is a wrapper around the setnx Redis command.

It takes the same arguments as the Redis command.

setrange

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (setrange r key offset value)

is a wrapper around the setrange Redis command.

It takes the same arguments as the Redis command.

shutdown

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (shutdown r)

is a wrapper around the shutdown Redis command.

It takes the same arguments as the Redis command.

sinter

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (sinter r key)

is a wrapper around the sinter Redis command.

It takes the same arguments as the Redis command.

sintercard

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (sintercard r numkeys key)

is a wrapper around the sintercard Redis command.

It takes the same arguments as the Redis command.

sinterstore

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (sinterstore r destination key)

is a wrapper around the sinterstore Redis command.

It takes the same arguments as the Redis command.

sismember

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (sismember r key member)

is a wrapper around the sismember Redis command.

It takes the same arguments as the Redis command.

slaveof

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (slaveof r host port)

is a wrapper around the slaveof Redis command.

It takes the same arguments as the Redis command.

slowlog

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (slowlog r subcommand)

is a wrapper around the slowlog Redis command.

It takes the same arguments as the Redis command.

smembers

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (smembers r key)

is a wrapper around the smembers Redis command.

It takes the same arguments as the Redis command.

smismember

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (smismember r key member)

is a wrapper around the smismember Redis command.

It takes the same arguments as the Redis command.

smove

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (smove r source destination member)

is a wrapper around the smove Redis command.

It takes the same arguments as the Redis command.

sock

instantiate

(Fn [(Ref Redis a)] (Ref Socket a))

gets the sock property of a Redis.

sort

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (sort r key)

is a wrapper around the sort Redis command.

It takes the same arguments as the Redis command.

sort_ro

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (sort_ro r key)

is a wrapper around the sort_ro Redis command.

It takes the same arguments as the Redis command.

spop

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (spop r key)

is a wrapper around the spop Redis command.

It takes the same arguments as the Redis command.

spublish

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (spublish r channel message)

is a wrapper around the spublish Redis command.

It takes the same arguments as the Redis command.

srandmember

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (srandmember r key)

is a wrapper around the srandmember Redis command.

It takes the same arguments as the Redis command.

srem

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (srem r key member)

is a wrapper around the srem Redis command.

It takes the same arguments as the Redis command.

sscan

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (sscan r key cursor)

is a wrapper around the sscan Redis command.

It takes the same arguments as the Redis command.

ssubscribe

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (ssubscribe r channel)

is a wrapper around the ssubscribe Redis command.

It takes the same arguments as the Redis command.

str

instantiate

(Fn [(Ref Redis a)] String)

converts a Redis to a string.

strlen

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (strlen r key)

is a wrapper around the strlen Redis command.

It takes the same arguments as the Redis command.

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (subscribe r channel)

is a wrapper around the subscribe Redis command.

It takes the same arguments as the Redis command.

sunion

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (sunion r key)

is a wrapper around the sunion Redis command.

It takes the same arguments as the Redis command.

sunionstore

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (sunionstore r destination key)

is a wrapper around the sunionstore Redis command.

It takes the same arguments as the Redis command.

sunsubscribe

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (sunsubscribe r)

is a wrapper around the sunsubscribe Redis command.

It takes the same arguments as the Redis command.

swapdb

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (swapdb r index1 index2)

is a wrapper around the swapdb Redis command.

It takes the same arguments as the Redis command.

sync

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (sync r)

is a wrapper around the sync Redis command.

It takes the same arguments as the Redis command.

time

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (time r)

is a wrapper around the time Redis command.

It takes the same arguments as the Redis command.

touch

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (touch r key)

is a wrapper around the touch Redis command.

It takes the same arguments as the Redis command.

ttl

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (ttl r key)

is a wrapper around the ttl Redis command.

It takes the same arguments as the Redis command.

type

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (type r key)

is a wrapper around the type Redis command.

It takes the same arguments as the Redis command.

unlink

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (unlink r key)

is a wrapper around the unlink Redis command.

It takes the same arguments as the Redis command.

unsubscribe

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (unsubscribe r)

is a wrapper around the unsubscribe Redis command.

It takes the same arguments as the Redis command.

unwatch

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (unwatch r)

is a wrapper around the unwatch Redis command.

It takes the same arguments as the Redis command.

update-sock

instantiate

(Fn [Redis, (Ref (Fn [Socket] Socket a) b)] Redis)

updates the sock property of a Redis using a function f.

wait

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (wait r numreplicas timeout)

is a wrapper around the wait Redis command.

It takes the same arguments as the Redis command.

waitaof

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (waitaof r numlocal numreplicas timeout)

is a wrapper around the waitaof Redis command.

It takes the same arguments as the Redis command.

watch

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (watch r key)

is a wrapper around the watch Redis command.

It takes the same arguments as the Redis command.

xack

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (xack r key group ID)

is a wrapper around the xack Redis command.

It takes the same arguments as the Redis command.

xadd

defn

(Fn [(Ref Redis a), b, c, d, e] (Result RESP String))

                        (xadd r key ID field value)

is a wrapper around the xadd Redis command.

It takes the same arguments as the Redis command.

xautoclaim

defn

(Fn [(Ref Redis a), b, c, d, e, f] (Result RESP String))

                        (xautoclaim r key group consumer min-idle-time start)

is a wrapper around the xautoclaim Redis command.

It takes the same arguments as the Redis command.

xclaim

defn

(Fn [(Ref Redis a), b, c, d, e, f] (Result RESP String))

                        (xclaim r key group consumer min-idle-time ID)

is a wrapper around the xclaim Redis command.

It takes the same arguments as the Redis command.

xdel

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (xdel r key ID)

is a wrapper around the xdel Redis command.

It takes the same arguments as the Redis command.

xgroup

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (xgroup r)

is a wrapper around the xgroup Redis command.

It takes the same arguments as the Redis command.

xgroup-createconsumer

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (xgroup-createconsumer r key groupname consumername)

is a wrapper around the xgroup createconsumer Redis command.

It takes the same arguments as the Redis command.

xgroup-delconsumer

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (xgroup-delconsumer r key groupname consumername)

is a wrapper around the xgroup delconsumer Redis command.

It takes the same arguments as the Redis command.

xinfo

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (xinfo r)

is a wrapper around the xinfo Redis command.

It takes the same arguments as the Redis command.

xlen

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (xlen r key)

is a wrapper around the xlen Redis command.

It takes the same arguments as the Redis command.

xpending

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (xpending r key group)

is a wrapper around the xpending Redis command.

It takes the same arguments as the Redis command.

xrange

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (xrange r key start end)

is a wrapper around the xrange Redis command.

It takes the same arguments as the Redis command.

xread

defn

(Fn [(Ref Redis a)] (Result RESP String))

                        (xread r)

is a wrapper around the xread Redis command.

It takes the same arguments as the Redis command.

xreadgroup

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (xreadgroup r GROUP group consumer)

is a wrapper around the xreadgroup Redis command.

It takes the same arguments as the Redis command.

xrevrange

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (xrevrange r key end start)

is a wrapper around the xrevrange Redis command.

It takes the same arguments as the Redis command.

xtrim

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (xtrim r key MAXLEN count)

is a wrapper around the xtrim Redis command.

It takes the same arguments as the Redis command.

zadd

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (zadd r key)

is a wrapper around the zadd Redis command.

It takes the same arguments as the Redis command.

zcard

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (zcard r key)

is a wrapper around the zcard Redis command.

It takes the same arguments as the Redis command.

zcount

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (zcount r key min max)

is a wrapper around the zcount Redis command.

It takes the same arguments as the Redis command.

zdiff

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (zdiff r numkeys key)

is a wrapper around the zdiff Redis command.

It takes the same arguments as the Redis command.

zdiffstore

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (zdiffstore r destination numkeys key)

is a wrapper around the zdiffstore Redis command.

It takes the same arguments as the Redis command.

zincrby

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (zincrby r key increment member)

is a wrapper around the zincrby Redis command.

It takes the same arguments as the Redis command.

zinter

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (zinter r numkeys key)

is a wrapper around the zinter Redis command.

It takes the same arguments as the Redis command.

zintercard

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (zintercard r numkeys key)

is a wrapper around the zintercard Redis command.

It takes the same arguments as the Redis command.

zinterstore

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (zinterstore r destination numkeys key)

is a wrapper around the zinterstore Redis command.

It takes the same arguments as the Redis command.

zlexcount

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (zlexcount r key min max)

is a wrapper around the zlexcount Redis command.

It takes the same arguments as the Redis command.

zmpop

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (zmpop r numkeys key)

is a wrapper around the zmpop Redis command.

It takes the same arguments as the Redis command.

zmscore

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (zmscore r key member)

is a wrapper around the zmscore Redis command.

It takes the same arguments as the Redis command.

zpopmax

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (zpopmax r key)

is a wrapper around the zpopmax Redis command.

It takes the same arguments as the Redis command.

zpopmin

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (zpopmin r key)

is a wrapper around the zpopmin Redis command.

It takes the same arguments as the Redis command.

zrandmember

defn

(Fn [(Ref Redis a), b] (Result RESP String))

                        (zrandmember r key)

is a wrapper around the zrandmember Redis command.

It takes the same arguments as the Redis command.

zrange

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (zrange r key start stop)

is a wrapper around the zrange Redis command.

It takes the same arguments as the Redis command.

zrangebylex

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (zrangebylex r key min max)

is a wrapper around the zrangebylex Redis command.

It takes the same arguments as the Redis command.

zrangebyscore

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (zrangebyscore r key min max)

is a wrapper around the zrangebyscore Redis command.

It takes the same arguments as the Redis command.

zrangestore

defn

(Fn [(Ref Redis a), b, c, d, e] (Result RESP String))

                        (zrangestore r dst src min max)

is a wrapper around the zrangestore Redis command.

It takes the same arguments as the Redis command.

zrank

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (zrank r key member)

is a wrapper around the zrank Redis command.

It takes the same arguments as the Redis command.

zrem

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (zrem r key member)

is a wrapper around the zrem Redis command.

It takes the same arguments as the Redis command.

zremrangebylex

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (zremrangebylex r key min max)

is a wrapper around the zremrangebylex Redis command.

It takes the same arguments as the Redis command.

zremrangebyrank

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (zremrangebyrank r key start stop)

is a wrapper around the zremrangebyrank Redis command.

It takes the same arguments as the Redis command.

zremrangebyscore

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (zremrangebyscore r key min max)

is a wrapper around the zremrangebyscore Redis command.

It takes the same arguments as the Redis command.

zrevrange

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (zrevrange r key start stop)

is a wrapper around the zrevrange Redis command.

It takes the same arguments as the Redis command.

zrevrangebylex

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (zrevrangebylex r key max min)

is a wrapper around the zrevrangebylex Redis command.

It takes the same arguments as the Redis command.

zrevrangebyscore

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (zrevrangebyscore r key max min)

is a wrapper around the zrevrangebyscore Redis command.

It takes the same arguments as the Redis command.

zrevrank

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (zrevrank r key member)

is a wrapper around the zrevrank Redis command.

It takes the same arguments as the Redis command.

zscan

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (zscan r key cursor)

is a wrapper around the zscan Redis command.

It takes the same arguments as the Redis command.

zscore

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (zscore r key member)

is a wrapper around the zscore Redis command.

It takes the same arguments as the Redis command.

zunion

defn

(Fn [(Ref Redis a), b, c] (Result RESP String))

                        (zunion r numkeys key)

is a wrapper around the zunion Redis command.

It takes the same arguments as the Redis command.

zunionstore

defn

(Fn [(Ref Redis a), b, c, d] (Result RESP String))

                        (zunionstore r destination numkeys key)

is a wrapper around the zunionstore Redis command.

It takes the same arguments as the Redis command.