Safe Haskell	None
Language	Haskell98

Database.Redis

Contents

How To Use This Module
The Redis Monad
Connection
Commands
Unimplemented Commands
Transactions
Pub/Sub
Low-Level Command API

Synopsis

How To Use This Module

Connect to a Redis server:

-- connects to localhost:6379
conn <- connect defaultConnectInfo

Send commands to the server:

{-# LANGUAGE OverloadedStrings #-}
...
runRedis conn $ do
     set "hello" "hello"
     set "world" "world"
     hello <- get "hello"
     world <- get "world"
     liftIO $ print (hello,world)

Command Type Signatures

Redis commands behave differently when issued in- or outside of a transaction. To make them work in both contexts, most command functions have a type signature similar to the following:

 echo :: (RedisCtx m f) => ByteString -> m (f ByteString)

Here is how to interpret this type signature:

The argument types are independent of the execution context. echo always takes a ByteString parameter, whether in- or outside of a transaction. This is true for all command functions.
All Redis commands return their result wrapped in some "container". The type f of this container depends on the commands execution context m. The ByteString return type in the example is specific to the echo command. For other commands, it will often be another type.
In the "normal" context Redis, outside of any transactions, results are wrapped in an Either Reply.
Inside a transaction, in the RedisTx context, results are wrapped in a Queued.

In short, you can view any command with a RedisCtx constraint in the type signature, to "have two types". For example echo "has both types":

 echo :: ByteString -> Redis (Either Reply ByteString)
 echo :: ByteString -> RedisTx (Queued ByteString)

Exercise: What are the types of expire inside a transaction and lindex outside of a transaction? The solutions are at the very bottom of this page.

Lua Scripting

Lua values returned from the eval and evalsha functions will be converted to Haskell values by the decode function from the RedisResult type class.

 Lua Type      | Haskell Type       | Conversion Example
 --------------|--------------------|-----------------------------
 Number        | Integer            | 1.23   => 1
 String        | ByteString, Double | "1.23" => "1.23" or 1.23
 Boolean       | Bool               | false  => False
 Table         | List               | {1,2}  => [1,2]

Additionally, any of the Haskell types from the table above can be wrapped in a Maybe:

 42  => Just 42 :: Maybe Integer
 nil => Nothing :: Maybe Integer

Note that Redis imposes some limitations on the possible conversions:

Lua numbers can only be converted to Integers. Only Lua strings can be interpreted as Doubles.
Associative Lua tables can not be converted at all. Returned tables must be "arrays", i.e. indexed only by integers.

The Redis Scripting website (http://redis.io/commands/eval) documents the exact semantics of the scripting commands and value conversion.

Automatic Pipelining

Commands are automatically pipelined as much as possible. For example, in the above "hello world" example, all four commands are pipelined. Automatic pipelining makes use of Haskell's laziness. As long as a previous reply is not evaluated, subsequent commands can be pipelined.

Automatic pipelining is limited to the scope of runRedis call and it is guaranteed that every reply expected as a part of runRedis execution gets received after runRedis invocation.

To keep memory usage low, the number of requests "in the pipeline" is limited (per connection) to 1000. After that number, the next command is sent only when at least one reply has been received. That means, command functions may block until there are less than 1000 outstanding replies.

Error Behavior

Operations against keys holding the wrong kind of value:: Outside of a transaction, if the Redis server returns an Error, command functions will return Left the Reply. The library user can inspect the error message to gain information on what kind of error occured.
Connection to the server lost:: In case of a lost connection, command functions throw a ConnectionLostException. It can only be caught outside of runRedis.
Exceptions:: Any exceptions can only be caught outside of runRedis. This way the connection pool can properly close the connection, making sure it is not left in an unusable state, e.g. closed or inside a transaction.

The Redis Monad

data Redis a Source

Context for normal command execution, outside of transactions. Use runRedis to run actions of this type.

In this context, each result is wrapped in an Either to account for the possibility of Redis returning an Error reply.

Instances

Monad Redis Source
Functor Redis Source
Applicative Redis Source
MonadIO Redis Source
MonadRedis Redis Source
RedisCtx Redis (Either Reply) Source

runRedis :: Connection -> Redis a -> IO a Source

Interact with a Redis datastore specified by the given Connection.

Each call of runRedis takes a network connection from the Connection pool and runs the given Redis action. Calls to runRedis may thus block while all connections from the pool are in use.

unRedis :: Redis a -> ReaderT RedisEnv IO a Source

Deconstruct Redis constructor.

unRedis and reRedis can be used to define instances for arbitrary typeclasses.

WARNING! These functions are considered internal and no guarantee is given at this point that they will not break in future.

reRedis :: ReaderT RedisEnv IO a -> Redis a Source

Reconstruct Redis constructor.

class MonadRedis m => RedisCtx m f | m -> f Source

This class captures the following behaviour: In a context m, a command will return it's result wrapped in a "container" of type f.

Please refer to the Command Type Signatures section of this page for more information.

Minimal complete definition

returnDecode

Instances

RedisCtx RedisTx Queued Source
RedisCtx Redis (Either Reply) Source

class Monad m => MonadRedis m where Source

Methods

liftRedis :: Redis a -> m a Source

Instances

MonadRedis Redis Source
MonadRedis RedisTx Source

Connection

data Connection Source

A threadsafe pool of network connections to a Redis server. Use the connect function to create one.

connect :: ConnectInfo -> IO Connection Source

Opens a Connection to a Redis server designated by the given ConnectInfo.

data ConnectInfo Source

Information for connnecting to a Redis server.

It is recommended to not use the ConnInfo data constructor directly. Instead use defaultConnectInfo and update it with record syntax. For example to connect to a password protected Redis server running on localhost and listening to the default port:

myConnectInfo :: ConnectInfo
myConnectInfo = defaultConnectInfo {connectAuth = Just "secret"}

Constructors

ConnInfo

Fields

connectHost :: HostName
connectPort :: PortID
connectAuth :: Maybe ByteString: When the server is protected by a password, set connectAuth to Just the password. Each connection will then authenticate by the auth command.
connectDatabase :: Integer: Each connection will select the database with the given index.
connectMaxConnections :: Int: Maximum number of connections to keep open. The smallest acceptable value is 1.
connectMaxIdleTime :: NominalDiffTime: Amount of time for which an unused connection is kept open. The smallest acceptable value is 0.5 seconds. If the timeout value in your redis.conf file is non-zero, it should be larger than connectMaxIdleTime.

Instances

Show ConnectInfo Source

defaultConnectInfo :: ConnectInfo Source

Default information for connecting:

 connectHost           = "localhost"
 connectPort           = PortNumber 6379 -- Redis default port
 connectAuth           = Nothing         -- No password
 connectDatabase       = 0               -- SELECT database 0
 connectMaxConnections = 50              -- Up to 50 connections
 connectMaxIdleTime    = 30              -- Keep open for 30 seconds

type HostName = String

Either a host name e.g., "haskell.org" or a numeric host address string consisting of a dotted decimal IPv4 address or an IPv6 address e.g., "192.168.0.1".

data PortID :: *

Constructors

Service String
PortNumber PortNumber
UnixSocket String

Instances

Eq PortID
Show PortID

Commands

Connection

auth Source

Arguments

:: ByteString	password
-> Redis (Either Reply Status)

Authenticate to the server (http://redis.io/commands/auth). Since Redis 1.0.0

echo Source

Arguments

:: RedisCtx m f
=> ByteString	message
-> m (f ByteString)

Echo the given string (http://redis.io/commands/echo). Since Redis 1.0.0

ping :: RedisCtx m f => m (f Status) Source

Ping the server (http://redis.io/commands/ping). Since Redis 1.0.0

quit :: RedisCtx m f => m (f Status) Source

Close the connection (http://redis.io/commands/quit). Since Redis 1.0.0

select Source

Arguments

:: RedisCtx m f
=> Integer	index
-> m (f Status)

Change the selected database for the current connection (http://redis.io/commands/select). Since Redis 1.0.0

Keys

del Source

Arguments

:: RedisCtx m f
=> [ByteString]	key
-> m (f Integer)

Delete a key (http://redis.io/commands/del). Since Redis 1.0.0

dump Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f ByteString)

Return a serialized version of the value stored at the specified key (http://redis.io/commands/dump). Since Redis 2.6.0

exists Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f Bool)

Determine if a key exists (http://redis.io/commands/exists). Since Redis 1.0.0

expire Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	seconds
-> m (f Bool)

Set a key's time to live in seconds (http://redis.io/commands/expire). Since Redis 1.0.0

expireat Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	timestamp
-> m (f Bool)

Set the expiration for a key as a UNIX timestamp (http://redis.io/commands/expireat). Since Redis 1.2.0

keys Source

Arguments

:: RedisCtx m f
=> ByteString	pattern
-> m (f [ByteString])

Find all keys matching the given pattern (http://redis.io/commands/keys). Since Redis 1.0.0

migrate Source

Arguments

:: RedisCtx m f
=> ByteString	host
-> ByteString	port
-> ByteString	key
-> Integer	destinationDb
-> Integer	timeout
-> m (f Status)

Atomically transfer a key from a Redis instance to another one (http://redis.io/commands/migrate). Since Redis 2.6.0

move Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	db
-> m (f Bool)

Move a key to another database (http://redis.io/commands/move). Since Redis 1.0.0

objectRefcount Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f Integer)

Inspect the internals of Redis objects (http://redis.io/commands/object). The Redis command OBJECT is split up into objectRefcount, objectEncoding, objectIdletime. Since Redis 2.2.3

objectEncoding Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f ByteString)

Inspect the internals of Redis objects (http://redis.io/commands/object). The Redis command OBJECT is split up into objectRefcount, objectEncoding, objectIdletime. Since Redis 2.2.3

objectIdletime Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f Integer)

Inspect the internals of Redis objects (http://redis.io/commands/object). The Redis command OBJECT is split up into objectRefcount, objectEncoding, objectIdletime. Since Redis 2.2.3

persist Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f Bool)

Remove the expiration from a key (http://redis.io/commands/persist). Since Redis 2.2.0

pexpire Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	milliseconds
-> m (f Bool)

Set a key's time to live in milliseconds (http://redis.io/commands/pexpire). Since Redis 2.6.0

pexpireat Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	millisecondsTimestamp
-> m (f Bool)

Set the expiration for a key as a UNIX timestamp specified in milliseconds (http://redis.io/commands/pexpireat). Since Redis 2.6.0

pttl Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f Integer)

Get the time to live for a key in milliseconds (http://redis.io/commands/pttl). Since Redis 2.6.0

randomkey :: RedisCtx m f => m (f (Maybe ByteString)) Source

Return a random key from the keyspace (http://redis.io/commands/randomkey). Since Redis 1.0.0

rename Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> ByteString	newkey
-> m (f Status)

Rename a key (http://redis.io/commands/rename). Since Redis 1.0.0

renamenx Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> ByteString	newkey
-> m (f Bool)

Rename a key, only if the new key does not exist (http://redis.io/commands/renamenx). Since Redis 1.0.0

restore Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	timeToLive
-> ByteString	serializedValue
-> m (f Status)

Create a key using the provided serialized value, previously obtained using DUMP (http://redis.io/commands/restore). Since Redis 2.6.0

data SortOpts Source

Options for the sort command.

Constructors

SortOpts
Fields sortBy :: Maybe ByteString sortLimit :: (Integer, Integer) sortGet :: [ByteString] sortOrder :: SortOrder sortAlpha :: Bool

Instances

Eq SortOpts Source
Show SortOpts Source

defaultSortOpts :: SortOpts Source

Redis default SortOpts. Equivalent to omitting all optional parameters.

SortOpts
    { sortBy    = Nothing -- omit the BY option
    , sortLimit = (0,-1)  -- return entire collection
    , sortGet   = []      -- omit the GET option
    , sortOrder = Asc     -- sort in ascending order
    , sortAlpha = False   -- sort numerically, not lexicographically
    }

data SortOrder Source

Constructors

Asc
Desc

Instances

Eq SortOrder Source
Show SortOrder Source

sort Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> SortOpts
-> m (f [ByteString])

Sort the elements in a list, set or sorted set (http://redis.io/commands/sort). The Redis command SORT is split up into sort, sortStore. Since Redis 1.0.0

sortStore Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> ByteString	destination
-> SortOpts
-> m (f Integer)

Sort the elements in a list, set or sorted set (http://redis.io/commands/sort). The Redis command SORT is split up into sort, sortStore. Since Redis 1.0.0

ttl Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f Integer)

Get the time to live for a key (http://redis.io/commands/ttl). Since Redis 1.0.0

data RedisType Source

Constructors

None
String
Hash
List
Set
ZSet

Instances

Eq RedisType Source
Show RedisType Source
RedisResult RedisType Source

getType Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f RedisType)

Determine the type stored at key (http://redis.io/commands/type). Since Redis 1.0.0

Hashes

hdel Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> [ByteString]	field
-> m (f Integer)

Delete one or more hash fields (http://redis.io/commands/hdel). Since Redis 2.0.0

hexists Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> ByteString	field
-> m (f Bool)

Determine if a hash field exists (http://redis.io/commands/hexists). Since Redis 2.0.0

hget Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> ByteString	field
-> m (f (Maybe ByteString))

Get the value of a hash field (http://redis.io/commands/hget). Since Redis 2.0.0

hgetall Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f [(ByteString, ByteString)])

Get all the fields and values in a hash (http://redis.io/commands/hgetall). Since Redis 2.0.0

hincrby Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> ByteString	field
-> Integer	increment
-> m (f Integer)

Increment the integer value of a hash field by the given number (http://redis.io/commands/hincrby). Since Redis 2.0.0

hincrbyfloat Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> ByteString	field
-> Double	increment
-> m (f Double)

Increment the float value of a hash field by the given amount (http://redis.io/commands/hincrbyfloat). Since Redis 2.6.0

hkeys Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f [ByteString])

Get all the fields in a hash (http://redis.io/commands/hkeys). Since Redis 2.0.0

hlen Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f Integer)

Get the number of fields in a hash (http://redis.io/commands/hlen). Since Redis 2.0.0

hmget Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> [ByteString]	field
-> m (f [Maybe ByteString])

Get the values of all the given hash fields (http://redis.io/commands/hmget). Since Redis 2.0.0

hmset Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> [(ByteString, ByteString)]	fieldValue
-> m (f Status)

Set multiple hash fields to multiple values (http://redis.io/commands/hmset). Since Redis 2.0.0

hset Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> ByteString	field
-> ByteString	value
-> m (f Bool)

Set the string value of a hash field (http://redis.io/commands/hset). Since Redis 2.0.0

hsetnx Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> ByteString	field
-> ByteString	value
-> m (f Bool)

Set the value of a hash field, only if the field does not exist (http://redis.io/commands/hsetnx). Since Redis 2.0.0

hvals Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f [ByteString])

Get all the values in a hash (http://redis.io/commands/hvals). Since Redis 2.0.0

HyperLogLogs

pfadd Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> [ByteString]	value
-> m (f Integer)

Adds all the elements arguments to the HyperLogLog data structure stored at the variable name specified as first argument (http://redis.io/commands/pfadd). Since Redis 2.8.9

pfcount Source

Arguments

:: RedisCtx m f
=> [ByteString]	key
-> m (f Integer)

Returns the approximated cardinality for the union of the HyperLogLogs stored in the specified keys (http://redis.io/commands/pfcount). Since Redis 2.8.9

pfmerge Source

Arguments

:: RedisCtx m f
=> ByteString	destkey
-> [ByteString]	sourcekey
-> m (f ByteString)

Merge multiple HyperLogLog values into an unique value that will approximate the cardinality of the union of the observed Sets of the source HyperLogLog structures (http://redis.io/commands/pfmerge). Since Redis 2.8.9

Lists

blpop Source

Arguments

:: RedisCtx m f
=> [ByteString]	key
-> Integer	timeout
-> m (f (Maybe (ByteString, ByteString)))

Remove and get the first element in a list, or block until one is available (http://redis.io/commands/blpop). Since Redis 2.0.0

brpop Source

Arguments

:: RedisCtx m f
=> [ByteString]	key
-> Integer	timeout
-> m (f (Maybe (ByteString, ByteString)))

Remove and get the last element in a list, or block until one is available (http://redis.io/commands/brpop). Since Redis 2.0.0

brpoplpush Source

Arguments

:: RedisCtx m f
=> ByteString	source
-> ByteString	destination
-> Integer	timeout
-> m (f (Maybe ByteString))

Pop a value from a list, push it to another list and return it; or block until one is available (http://redis.io/commands/brpoplpush). Since Redis 2.2.0

lindex Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	index
-> m (f (Maybe ByteString))

Get an element from a list by its index (http://redis.io/commands/lindex). Since Redis 1.0.0

linsertBefore Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> ByteString	pivot
-> ByteString	value
-> m (f Integer)

Insert an element before or after another element in a list (http://redis.io/commands/linsert). The Redis command LINSERT is split up into linsertBefore, linsertAfter. Since Redis 2.2.0

linsertAfter Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> ByteString	pivot
-> ByteString	value
-> m (f Integer)

Insert an element before or after another element in a list (http://redis.io/commands/linsert). The Redis command LINSERT is split up into linsertBefore, linsertAfter. Since Redis 2.2.0

llen Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f Integer)

Get the length of a list (http://redis.io/commands/llen). Since Redis 1.0.0

lpop Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f (Maybe ByteString))

Remove and get the first element in a list (http://redis.io/commands/lpop). Since Redis 1.0.0

lpush Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> [ByteString]	value
-> m (f Integer)

Prepend one or multiple values to a list (http://redis.io/commands/lpush). Since Redis 1.0.0

lpushx Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> ByteString	value
-> m (f Integer)

Prepend a value to a list, only if the list exists (http://redis.io/commands/lpushx). Since Redis 2.2.0

lrange Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	start
-> Integer	stop
-> m (f [ByteString])

Get a range of elements from a list (http://redis.io/commands/lrange). Since Redis 1.0.0

lrem Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	count
-> ByteString	value
-> m (f Integer)

Remove elements from a list (http://redis.io/commands/lrem). Since Redis 1.0.0

lset Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	index
-> ByteString	value
-> m (f Status)

Set the value of an element in a list by its index (http://redis.io/commands/lset). Since Redis 1.0.0

ltrim Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	start
-> Integer	stop
-> m (f Status)

Trim a list to the specified range (http://redis.io/commands/ltrim). Since Redis 1.0.0

rpop Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f (Maybe ByteString))

Remove and get the last element in a list (http://redis.io/commands/rpop). Since Redis 1.0.0

rpoplpush Source

Arguments

:: RedisCtx m f
=> ByteString	source
-> ByteString	destination
-> m (f (Maybe ByteString))

Remove the last element in a list, append it to another list and return it (http://redis.io/commands/rpoplpush). Since Redis 1.2.0

rpush Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> [ByteString]	value
-> m (f Integer)

Append one or multiple values to a list (http://redis.io/commands/rpush). Since Redis 1.0.0

rpushx Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> ByteString	value
-> m (f Integer)

Append a value to a list, only if the list exists (http://redis.io/commands/rpushx). Since Redis 2.2.0

Scripting

eval Source

Arguments

:: (RedisCtx m f, RedisResult a)
=> ByteString	script
-> [ByteString]	keys
-> [ByteString]	args
-> m (f a)

Execute a Lua script server side (http://redis.io/commands/eval). Since Redis 2.6.0

evalsha Source

Arguments

:: (RedisCtx m f, RedisResult a)
=> ByteString	script
-> [ByteString]	keys
-> [ByteString]	args
-> m (f a)

Execute a Lua script server side (http://redis.io/commands/evalsha). Since Redis 2.6.0

scriptExists Source

Arguments

:: RedisCtx m f
=> [ByteString]	script
-> m (f [Bool])

Check existence of scripts in the script cache (http://redis.io/commands/script-exists). Since Redis 2.6.0

scriptFlush :: RedisCtx m f => m (f Status) Source

Remove all the scripts from the script cache (http://redis.io/commands/script-flush). Since Redis 2.6.0

scriptKill :: RedisCtx m f => m (f Status) Source

Kill the script currently in execution (http://redis.io/commands/script-kill). Since Redis 2.6.0

scriptLoad Source

Arguments

:: RedisCtx m f
=> ByteString	script
-> m (f ByteString)

Load the specified Lua script into the script cache (http://redis.io/commands/script-load). Since Redis 2.6.0

Server

bgrewriteaof :: RedisCtx m f => m (f Status) Source

Asynchronously rewrite the append-only file (http://redis.io/commands/bgrewriteaof). Since Redis 1.0.0

bgsave :: RedisCtx m f => m (f Status) Source

Asynchronously save the dataset to disk (http://redis.io/commands/bgsave). Since Redis 1.0.0

configGet Source

Arguments

:: RedisCtx m f
=> ByteString	parameter
-> m (f [(ByteString, ByteString)])

Get the value of a configuration parameter (http://redis.io/commands/config-get). Since Redis 2.0.0

configResetstat :: RedisCtx m f => m (f Status) Source

Reset the stats returned by INFO (http://redis.io/commands/config-resetstat). Since Redis 2.0.0

configSet Source

Arguments

:: RedisCtx m f
=> ByteString	parameter
-> ByteString	value
-> m (f Status)

Set a configuration parameter to the given value (http://redis.io/commands/config-set). Since Redis 2.0.0

dbsize :: RedisCtx m f => m (f Integer) Source

Return the number of keys in the selected database (http://redis.io/commands/dbsize). Since Redis 1.0.0

debugObject Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f ByteString)

Get debugging information about a key (http://redis.io/commands/debug-object). Since Redis 1.0.0

flushall :: RedisCtx m f => m (f Status) Source

Remove all keys from all databases (http://redis.io/commands/flushall). Since Redis 1.0.0

flushdb :: RedisCtx m f => m (f Status) Source

Remove all keys from the current database (http://redis.io/commands/flushdb). Since Redis 1.0.0

info :: RedisCtx m f => m (f ByteString) Source

Get information and statistics about the server (http://redis.io/commands/info). Since Redis 1.0.0

lastsave :: RedisCtx m f => m (f Integer) Source

Get the UNIX time stamp of the last successful save to disk (http://redis.io/commands/lastsave). Since Redis 1.0.0

save :: RedisCtx m f => m (f Status) Source

Synchronously save the dataset to disk (http://redis.io/commands/save). Since Redis 1.0.0

slaveof Source

Arguments

:: RedisCtx m f
=> ByteString	host
-> ByteString	port
-> m (f Status)

Make the server a slave of another instance, or promote it as master (http://redis.io/commands/slaveof). Since Redis 1.0.0

data Slowlog Source

A single entry from the slowlog.

Constructors

Slowlog
Fields slowlogId :: Integer A unique progressive identifier for every slow log entry. slowlogTimestamp :: Integer The unix timestamp at which the logged command was processed. slowlogMicros :: Integer The amount of time needed for its execution, in microseconds. slowlogCmd :: [ByteString] The command and it's arguments.

Instances

Eq Slowlog Source
Show Slowlog Source
RedisResult Slowlog Source

slowlogGet Source

Arguments

:: RedisCtx m f
=> Integer	cnt
-> m (f [Slowlog])

Manages the Redis slow queries log (http://redis.io/commands/slowlog). The Redis command SLOWLOG is split up into slowlogGet, slowlogLen, slowlogReset. Since Redis 2.2.12

slowlogLen :: RedisCtx m f => m (f Integer) Source

Manages the Redis slow queries log (http://redis.io/commands/slowlog). The Redis command SLOWLOG is split up into slowlogGet, slowlogLen, slowlogReset. Since Redis 2.2.12

slowlogReset :: RedisCtx m f => m (f Status) Source

Manages the Redis slow queries log (http://redis.io/commands/slowlog). The Redis command SLOWLOG is split up into slowlogGet, slowlogLen, slowlogReset. Since Redis 2.2.12

time :: RedisCtx m f => m (f (Integer, Integer)) Source

Return the current server time (http://redis.io/commands/time). Since Redis 2.6.0

Sets

sadd Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> [ByteString]	member
-> m (f Integer)

Add one or more members to a set (http://redis.io/commands/sadd). Since Redis 1.0.0

scard Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f Integer)

Get the number of members in a set (http://redis.io/commands/scard). Since Redis 1.0.0

sdiff Source

Arguments

:: RedisCtx m f
=> [ByteString]	key
-> m (f [ByteString])

Subtract multiple sets (http://redis.io/commands/sdiff). Since Redis 1.0.0

sdiffstore Source

Arguments

:: RedisCtx m f
=> ByteString	destination
-> [ByteString]	key
-> m (f Integer)

Subtract multiple sets and store the resulting set in a key (http://redis.io/commands/sdiffstore). Since Redis 1.0.0

sinter Source

Arguments

:: RedisCtx m f
=> [ByteString]	key
-> m (f [ByteString])

Intersect multiple sets (http://redis.io/commands/sinter). Since Redis 1.0.0

sinterstore Source

Arguments

:: RedisCtx m f
=> ByteString	destination
-> [ByteString]	key
-> m (f Integer)

Intersect multiple sets and store the resulting set in a key (http://redis.io/commands/sinterstore). Since Redis 1.0.0

sismember Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> ByteString	member
-> m (f Bool)

Determine if a given value is a member of a set (http://redis.io/commands/sismember). Since Redis 1.0.0

smembers Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f [ByteString])

Get all the members in a set (http://redis.io/commands/smembers). Since Redis 1.0.0

smove Source

Arguments

:: RedisCtx m f
=> ByteString	source
-> ByteString	destination
-> ByteString	member
-> m (f Bool)

Move a member from one set to another (http://redis.io/commands/smove). Since Redis 1.0.0

spop Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f (Maybe ByteString))

Remove and return a random member from a set (http://redis.io/commands/spop). Since Redis 1.0.0

srandmember Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f (Maybe ByteString))

Get a random member from a set (http://redis.io/commands/srandmember). Since Redis 1.0.0

srem Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> [ByteString]	member
-> m (f Integer)

Remove one or more members from a set (http://redis.io/commands/srem). Since Redis 1.0.0

sunion Source

Arguments

:: RedisCtx m f
=> [ByteString]	key
-> m (f [ByteString])

Add multiple sets (http://redis.io/commands/sunion). Since Redis 1.0.0

sunionstore Source

Arguments

:: RedisCtx m f
=> ByteString	destination
-> [ByteString]	key
-> m (f Integer)

Add multiple sets and store the resulting set in a key (http://redis.io/commands/sunionstore). Since Redis 1.0.0

Sorted Sets

zadd Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> [(Double, ByteString)]	scoreMember
-> m (f Integer)

Add one or more members to a sorted set, or update its score if it already exists (http://redis.io/commands/zadd). Since Redis 1.2.0

zcard Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f Integer)

Get the number of members in a sorted set (http://redis.io/commands/zcard). Since Redis 1.2.0

zcount Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Double	min
-> Double	max
-> m (f Integer)

Count the members in a sorted set with scores within the given values (http://redis.io/commands/zcount). Since Redis 2.0.0

zincrby Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	increment
-> ByteString	member
-> m (f Double)

Increment the score of a member in a sorted set (http://redis.io/commands/zincrby). Since Redis 1.2.0

data Aggregate Source

Constructors

Sum
Min
Max

Instances

Eq Aggregate Source
Show Aggregate Source

zinterstore Source

Arguments

:: RedisCtx m f
=> ByteString	destination
-> [ByteString]	keys
-> Aggregate
-> m (f Integer)

Intersect multiple sorted sets and store the resulting sorted set in a new key (http://redis.io/commands/zinterstore). The Redis command ZINTERSTORE is split up into zinterstore, zinterstoreWeights. Since Redis 2.0.0

zinterstoreWeights Source

Arguments

:: RedisCtx m f
=> ByteString	destination
-> [(ByteString, Double)]	weighted keys
-> Aggregate
-> m (f Integer)

Intersect multiple sorted sets and store the resulting sorted set in a new key (http://redis.io/commands/zinterstore). The Redis command ZINTERSTORE is split up into zinterstore, zinterstoreWeights. Since Redis 2.0.0

zrange Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	start
-> Integer	stop
-> m (f [ByteString])

Return a range of members in a sorted set, by index (http://redis.io/commands/zrange). The Redis command ZRANGE is split up into zrange, zrangeWithscores. Since Redis 1.2.0

zrangeWithscores Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	start
-> Integer	stop
-> m (f [(ByteString, Double)])

Return a range of members in a sorted set, by index (http://redis.io/commands/zrange). The Redis command ZRANGE is split up into zrange, zrangeWithscores. Since Redis 1.2.0

zrangebyscore Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Double	min
-> Double	max
-> m (f [ByteString])

Return a range of members in a sorted set, by score (http://redis.io/commands/zrangebyscore). The Redis command ZRANGEBYSCORE is split up into zrangebyscore, zrangebyscoreWithscores, zrangebyscoreLimit, zrangebyscoreWithscoresLimit. Since Redis 1.0.5

zrangebyscoreWithscores Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Double	min
-> Double	max
-> m (f [(ByteString, Double)])

Return a range of members in a sorted set, by score (http://redis.io/commands/zrangebyscore). The Redis command ZRANGEBYSCORE is split up into zrangebyscore, zrangebyscoreWithscores, zrangebyscoreLimit, zrangebyscoreWithscoresLimit. Since Redis 1.0.5

zrangebyscoreLimit Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Double	min
-> Double	max
-> Integer	offset
-> Integer	count
-> m (f [ByteString])

Return a range of members in a sorted set, by score (http://redis.io/commands/zrangebyscore). The Redis command ZRANGEBYSCORE is split up into zrangebyscore, zrangebyscoreWithscores, zrangebyscoreLimit, zrangebyscoreWithscoresLimit. Since Redis 1.0.5

zrangebyscoreWithscoresLimit Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Double	min
-> Double	max
-> Integer	offset
-> Integer	count
-> m (f [(ByteString, Double)])

Return a range of members in a sorted set, by score (http://redis.io/commands/zrangebyscore). The Redis command ZRANGEBYSCORE is split up into zrangebyscore, zrangebyscoreWithscores, zrangebyscoreLimit, zrangebyscoreWithscoresLimit. Since Redis 1.0.5

zrank Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> ByteString	member
-> m (f (Maybe Integer))

Determine the index of a member in a sorted set (http://redis.io/commands/zrank). Since Redis 2.0.0

zrem Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> [ByteString]	member
-> m (f Integer)

Remove one or more members from a sorted set (http://redis.io/commands/zrem). Since Redis 1.2.0

zremrangebyrank Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	start
-> Integer	stop
-> m (f Integer)

Remove all members in a sorted set within the given indexes (http://redis.io/commands/zremrangebyrank). Since Redis 2.0.0

zremrangebyscore Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Double	min
-> Double	max
-> m (f Integer)

Remove all members in a sorted set within the given scores (http://redis.io/commands/zremrangebyscore). Since Redis 1.2.0

zrevrange Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	start
-> Integer	stop
-> m (f [ByteString])

Return a range of members in a sorted set, by index, with scores ordered from high to low (http://redis.io/commands/zrevrange). The Redis command ZREVRANGE is split up into zrevrange, zrevrangeWithscores. Since Redis 1.2.0

zrevrangeWithscores Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	start
-> Integer	stop
-> m (f [(ByteString, Double)])

Return a range of members in a sorted set, by index, with scores ordered from high to low (http://redis.io/commands/zrevrange). The Redis command ZREVRANGE is split up into zrevrange, zrevrangeWithscores. Since Redis 1.2.0

zrevrangebyscore Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Double	max
-> Double	min
-> m (f [ByteString])

Return a range of members in a sorted set, by score, with scores ordered from high to low (http://redis.io/commands/zrevrangebyscore). The Redis command ZREVRANGEBYSCORE is split up into zrevrangebyscore, zrevrangebyscoreWithscores, zrevrangebyscoreLimit, zrevrangebyscoreWithscoresLimit. Since Redis 2.2.0

zrevrangebyscoreWithscores Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Double	max
-> Double	min
-> m (f [(ByteString, Double)])

Return a range of members in a sorted set, by score, with scores ordered from high to low (http://redis.io/commands/zrevrangebyscore). The Redis command ZREVRANGEBYSCORE is split up into zrevrangebyscore, zrevrangebyscoreWithscores, zrevrangebyscoreLimit, zrevrangebyscoreWithscoresLimit. Since Redis 2.2.0

zrevrangebyscoreLimit Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Double	max
-> Double	min
-> Integer	offset
-> Integer	count
-> m (f [ByteString])

Return a range of members in a sorted set, by score, with scores ordered from high to low (http://redis.io/commands/zrevrangebyscore). The Redis command ZREVRANGEBYSCORE is split up into zrevrangebyscore, zrevrangebyscoreWithscores, zrevrangebyscoreLimit, zrevrangebyscoreWithscoresLimit. Since Redis 2.2.0

zrevrangebyscoreWithscoresLimit Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Double	max
-> Double	min
-> Integer	offset
-> Integer	count
-> m (f [(ByteString, Double)])

Return a range of members in a sorted set, by score, with scores ordered from high to low (http://redis.io/commands/zrevrangebyscore). The Redis command ZREVRANGEBYSCORE is split up into zrevrangebyscore, zrevrangebyscoreWithscores, zrevrangebyscoreLimit, zrevrangebyscoreWithscoresLimit. Since Redis 2.2.0

zrevrank Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> ByteString	member
-> m (f (Maybe Integer))

Determine the index of a member in a sorted set, with scores ordered from high to low (http://redis.io/commands/zrevrank). Since Redis 2.0.0

zscore Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> ByteString	member
-> m (f (Maybe Double))

Get the score associated with the given member in a sorted set (http://redis.io/commands/zscore). Since Redis 1.2.0

zunionstore Source

Arguments

:: RedisCtx m f
=> ByteString	destination
-> [ByteString]	keys
-> Aggregate
-> m (f Integer)

Add multiple sorted sets and store the resulting sorted set in a new key (http://redis.io/commands/zunionstore). The Redis command ZUNIONSTORE is split up into zunionstore, zunionstoreWeights. Since Redis 2.0.0

zunionstoreWeights Source

Arguments

:: RedisCtx m f
=> ByteString	destination
-> [(ByteString, Double)]	weighted keys
-> Aggregate
-> m (f Integer)

Add multiple sorted sets and store the resulting sorted set in a new key (http://redis.io/commands/zunionstore). The Redis command ZUNIONSTORE is split up into zunionstore, zunionstoreWeights. Since Redis 2.0.0

Strings

append Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> ByteString	value
-> m (f Integer)

Append a value to a key (http://redis.io/commands/append). Since Redis 2.0.0

bitcount Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f Integer)

Count set bits in a string (http://redis.io/commands/bitcount). The Redis command BITCOUNT is split up into bitcount, bitcountRange. Since Redis 2.6.0

bitcountRange Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	start
-> Integer	end
-> m (f Integer)

Count set bits in a string (http://redis.io/commands/bitcount). The Redis command BITCOUNT is split up into bitcount, bitcountRange. Since Redis 2.6.0

bitopAnd Source

Arguments

:: RedisCtx m f
=> ByteString	destkey
-> [ByteString]	srckeys
-> m (f Integer)

Perform bitwise operations between strings (http://redis.io/commands/bitop). The Redis command BITOP is split up into bitopAnd, bitopOr, bitopXor, bitopNot. Since Redis 2.6.0

bitopOr Source

Arguments

:: RedisCtx m f
=> ByteString	destkey
-> [ByteString]	srckeys
-> m (f Integer)

Perform bitwise operations between strings (http://redis.io/commands/bitop). The Redis command BITOP is split up into bitopAnd, bitopOr, bitopXor, bitopNot. Since Redis 2.6.0

bitopXor Source

Arguments

:: RedisCtx m f
=> ByteString	destkey
-> [ByteString]	srckeys
-> m (f Integer)

Perform bitwise operations between strings (http://redis.io/commands/bitop). The Redis command BITOP is split up into bitopAnd, bitopOr, bitopXor, bitopNot. Since Redis 2.6.0

bitopNot Source

Arguments

:: RedisCtx m f
=> ByteString	destkey
-> ByteString	srckey
-> m (f Integer)

Perform bitwise operations between strings (http://redis.io/commands/bitop). The Redis command BITOP is split up into bitopAnd, bitopOr, bitopXor, bitopNot. Since Redis 2.6.0

decr Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f Integer)

Decrement the integer value of a key by one (http://redis.io/commands/decr). Since Redis 1.0.0

decrby Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	decrement
-> m (f Integer)

Decrement the integer value of a key by the given number (http://redis.io/commands/decrby). Since Redis 1.0.0

get Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f (Maybe ByteString))

Get the value of a key (http://redis.io/commands/get). Since Redis 1.0.0

getbit Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	offset
-> m (f Integer)

Returns the bit value at offset in the string value stored at key (http://redis.io/commands/getbit). Since Redis 2.2.0

getrange Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	start
-> Integer	end
-> m (f ByteString)

Get a substring of the string stored at a key (http://redis.io/commands/getrange). Since Redis 2.4.0

getset Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> ByteString	value
-> m (f (Maybe ByteString))

Set the string value of a key and return its old value (http://redis.io/commands/getset). Since Redis 1.0.0

incr Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f Integer)

Increment the integer value of a key by one (http://redis.io/commands/incr). Since Redis 1.0.0

incrby Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	increment
-> m (f Integer)

Increment the integer value of a key by the given amount (http://redis.io/commands/incrby). Since Redis 1.0.0

incrbyfloat Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Double	increment
-> m (f Double)

Increment the float value of a key by the given amount (http://redis.io/commands/incrbyfloat). Since Redis 2.6.0

mget Source

Arguments

:: RedisCtx m f
=> [ByteString]	key
-> m (f [Maybe ByteString])

Get the values of all the given keys (http://redis.io/commands/mget). Since Redis 1.0.0

mset Source

Arguments

:: RedisCtx m f
=> [(ByteString, ByteString)]	keyValue
-> m (f Status)

Set multiple keys to multiple values (http://redis.io/commands/mset). Since Redis 1.0.1

msetnx Source

Arguments

:: RedisCtx m f
=> [(ByteString, ByteString)]	keyValue
-> m (f Bool)

Set multiple keys to multiple values, only if none of the keys exist (http://redis.io/commands/msetnx). Since Redis 1.0.1

psetex Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	milliseconds
-> ByteString	value
-> m (f Status)

Set the value and expiration in milliseconds of a key (http://redis.io/commands/psetex). Since Redis 2.6.0

set Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> ByteString	value
-> m (f Status)

Set the string value of a key (http://redis.io/commands/set). Since Redis 1.0.0

setbit Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	offset
-> ByteString	value
-> m (f Integer)

Sets or clears the bit at offset in the string value stored at key (http://redis.io/commands/setbit). Since Redis 2.2.0

setex Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	seconds
-> ByteString	value
-> m (f Status)

Set the value and expiration of a key (http://redis.io/commands/setex). Since Redis 2.0.0

setnx Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> ByteString	value
-> m (f Bool)

Set the value of a key, only if the key does not exist (http://redis.io/commands/setnx). Since Redis 1.0.0

setrange Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> Integer	offset
-> ByteString	value
-> m (f Integer)

Overwrite part of a string at key starting at the specified offset (http://redis.io/commands/setrange). Since Redis 2.2.0

strlen Source

Arguments

:: RedisCtx m f
=> ByteString	key
-> m (f Integer)

Get the length of the value stored in a key (http://redis.io/commands/strlen). Since Redis 2.2.0

Unimplemented Commands

These commands are not implemented, as of now. Library users can implement these or other commands from experimental Redis versions by using the sendRequest function.

MONITOR (http://redis.io/commands/monitor)
SYNC (http://redis.io/commands/sync)
SHUTDOWN (http://redis.io/commands/shutdown)
DEBUG SEGFAULT (http://redis.io/commands/debug-segfault)

Transactions

watch Source

Arguments

:: [ByteString]	key
-> Redis (Either Reply Status)

Watch the given keys to determine execution of the MULTI/EXEC block (http://redis.io/commands/watch).

unwatch :: Redis (Either Reply Status) Source

Forget about all watched keys (http://redis.io/commands/unwatch).

multiExec :: RedisTx (Queued a) -> Redis (TxResult a) Source

Run commands inside a transaction. For documentation on the semantics of Redis transaction see http://redis.io/topics/transactions.

Inside the transaction block, command functions return their result wrapped in a Queued. The Queued result is a proxy object for the actual command's result, which will only be available after EXECing the transaction.

Example usage (note how Queued 's Applicative instance is used to combine the two individual results):

 runRedis conn $ do
     set "hello" "hello"
     set "world" "world"
     helloworld <- multiExec $ do
         hello <- get "hello"
         world <- get "world"
         return $ (,) <$> hello <*> world
     liftIO (print helloworld)

data Queued a Source

A Queued value represents the result of a command inside a transaction. It is a proxy object for the actual result, which will only be available after returning from a multiExec transaction.

Queued values are composable by utilizing the Functor, Applicative or Monad interfaces.

Instances

Monad Queued Source
Functor Queued Source
Applicative Queued Source
RedisCtx RedisTx Queued Source

data TxResult a Source

Result of a multiExec transaction.

Constructors

TxSuccess a	Transaction completed successfully. The wrapped value corresponds to the `Queued` value returned from the `multiExec` argument action.
TxAborted	Transaction aborted due to an earlier `watch` command.
TxError String	At least one of the commands returned an `Error` reply.

Instances

Eq a => Eq (TxResult a) Source
Show a => Show (TxResult a) Source
Generic (TxResult a) Source
NFData a => NFData (TxResult a) Source
type Rep (TxResult a) Source

data RedisTx a Source

Command-context inside of MULTI/EXEC transactions. Use multiExec to run actions of this type.

In the RedisTx context, all commands return a Queued value. It is a proxy object for the actual result, which will only be available after finishing the transaction.

Instances

Monad RedisTx Source
Functor RedisTx Source
Applicative RedisTx Source
MonadIO RedisTx Source
MonadRedis RedisTx Source
RedisCtx RedisTx Queued Source

Pub/Sub

publish Source

Arguments

:: RedisCtx m f
=> ByteString	channel
-> ByteString	message
-> m (f Integer)

Post a message to a channel (http://redis.io/commands/publish).

pubSub Source

Arguments

:: PubSub	Initial subscriptions.
-> (Message -> IO PubSub)	Callback function.
-> Redis ()

Listens to published messages on subscribed channels and channels matching the subscribed patterns. For documentation on the semantics of Redis Pub/Sub see http://redis.io/topics/pubsub.

The given callback function is called for each received message. Subscription changes are triggered by the returned PubSub. To keep subscriptions unchanged, the callback can return mempty.

Example: Subscribe to the "news" channel indefinitely.

 pubSub (subscribe ["news"]) $ \msg -> do
     putStrLn $ "Message from " ++ show (msgChannel msg)
     return mempty

Example: Receive a single message from the "chat" channel.

 pubSub (subscribe ["chat"]) $ \msg -> do
     putStrLn $ "Message from " ++ show (msgChannel msg)
     return $ unsubscribe ["chat"]

It should be noted that Redis Pub/Sub by its nature is asynchronous so returning unsubscribe does not mean that callback won't be able to receive any further messages. And to guarantee that you won't won't process messages after unsubscription and won't unsubscribe from the same channel more than once you need to use IORef or something similar

data Message Source

Constructors

Message
Fields msgChannel, msgMessage :: ByteString
PMessage
Fields msgPattern, msgChannel, msgMessage :: ByteString

Instances

Show Message Source

data PubSub Source

Encapsulates subscription changes. Use subscribe, unsubscribe, psubscribe, punsubscribe or mempty to construct a value. Combine values by using the Monoid interface, i.e. mappend and mconcat.

Instances

Eq PubSub Source
Monoid PubSub Source

subscribe Source

Arguments

:: [ByteString]	channel
-> PubSub

Listen for messages published to the given channels (http://redis.io/commands/subscribe).

unsubscribe Source

Arguments

:: [ByteString]	channel
-> PubSub

Stop listening for messages posted to the given channels (http://redis.io/commands/unsubscribe).

psubscribe Source

Arguments

:: [ByteString]	pattern
-> PubSub

Listen for messages published to channels matching the given patterns (http://redis.io/commands/psubscribe).

punsubscribe Source

Arguments

:: [ByteString]	pattern
-> PubSub

Stop listening for messages posted to channels matching the given patterns (http://redis.io/commands/punsubscribe).

Low-Level Command API

sendRequest :: (RedisCtx m f, RedisResult a) => [ByteString] -> m (f a) Source

sendRequest can be used to implement commands from experimental versions of Redis. An example of how to implement a command is given below.

-- |Redis DEBUG OBJECT command
debugObject :: ByteString -> Redis (Either Reply ByteString)
debugObject key = sendRequest ["DEBUG", "OBJECT", key]

data Reply Source

Low-level representation of replies from the Redis server.

Constructors

SingleLine ByteString
Error ByteString
Integer Integer
Bulk (Maybe ByteString)
MultiBulk (Maybe [Reply])

Instances

Eq Reply Source
Show Reply Source
Generic Reply Source
NFData Reply Source
RedisResult Reply Source
RedisCtx Redis (Either Reply) Source
type Rep Reply Source

data Status Source

Constructors

Ok
Pong
Status ByteString

Instances

Eq Status Source
Show Status Source
Generic Status Source
NFData Status Source
RedisResult Status Source
type Rep Status Source

class RedisResult a where Source

Methods

decode :: Reply -> Either Reply a Source

Instances

RedisResult Bool Source
RedisResult Double Source
RedisResult Integer Source
RedisResult ByteString Source
RedisResult Reply Source
RedisResult RedisType Source
RedisResult Status Source
RedisResult Slowlog Source
(RedisResult k, RedisResult v) => RedisResult [(k, v)] Source
RedisResult a => RedisResult [a] Source
RedisResult a => RedisResult (Maybe a) Source
(RedisResult a, RedisResult b) => RedisResult (a, b) Source

data ConnectionLostException Source

Constructors

ConnectionLost

Instances

Show ConnectionLostException Source
Exception ConnectionLostException Source

Solution to Exercise

Type of expire inside a transaction:

expire :: ByteString -> Integer -> RedisTx (Queued Bool)

Type of lindex outside of a transaction:

lindex :: ByteString -> Integer -> Redis (Either Reply ByteString)