Redis

is a wrapper around Redis connections. It supports opening a connection using open or open-on, reading from and sending to the connection (using read and send, respectively), and contains thin wrappers around all Redis commands (everything else).

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.

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.

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-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-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-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-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-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-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-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-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-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-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.

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

instantiate

(Fn [(Ref Redis a)] Redis)

copies a Redis.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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-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.

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.

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.

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-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.

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.

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), b, (Ref (Array RESP) c)] ())

                    (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.

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.

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.

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.

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.

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.

subscribe

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.