Connect to a Redis server:

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

Connect to a Redis server using TLS:

-- connects to foobar.redis.cache.windows.net:6380
import Network.TLS
import Network.TLS.Extra.Cipher
import Data.X509.CertificateStore
import Data.Default.Class (def)
(Just certStore) <- readCertificateStore "azure-redis.crt"
let tlsParams = (defaultParamsClient "foobar.redis.cache.windows.net" "") { clientSupported = def { supportedCiphers = ciphersuite_strong }, clientShared = def { sharedCAStore = certStore } }
let redisConnInfo = defaultConnectInfo { connectHost = "foobar.redis.cache.windows.net", connectPort = PortNumber 6380, connectTLSParams = Just tlsParams, connectAuth = Just "Foobar!" }
conn <- checkedConnect redisConnInfo

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)

disconnect all idle resources in the connection pool:

disconnect conn

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

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.

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.

Trying to connect to an unreachable server:

When trying to connect to a server that does not exist or can't be reached, the connection pool only starts the first connection when actually executing a call to the server. This can lead to discovering very late that the server is not available, for example when running a server that logs to Redis. To prevent this, run a ping command directly after connecting or use the checkedConnect function which encapsulates this behavior.

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.

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

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

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

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

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

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

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

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

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

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

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

Atomically transfer a key from a Redis instance to another one (http://redis.io/commands/migrate). The Redis command MIGRATE is split up into migrate, migrateMultiple. Since Redis 2.6.0

Atomically transfer a key from a Redis instance to another one (http://redis.io/commands/migrate). The Redis command MIGRATE is split up into migrate, migrateMultiple. Since Redis 2.6.0

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

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

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

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

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

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

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

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

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

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

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

Create a key using the provided serialized value, previously obtained using DUMP (http://redis.io/commands/restore). The Redis command RESTORE is split up into restore, restoreReplace. Since Redis 2.6.0

Create a key using the provided serialized value, previously obtained using DUMP (http://redis.io/commands/restore). The Redis command RESTORE is split up into restore, restoreReplace. Since Redis 2.6.0

Incrementally iterate the keys space (http://redis.io/commands/scan). The Redis command SCAN is split up into scan, scanOpts. Since Redis 2.8.0

Incrementally iterate the keys space (http://redis.io/commands/scan). The Redis command SCAN is split up into scan, scanOpts. Since Redis 2.8.0

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

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

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

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

Wait for the synchronous replication of all the write commands sent in the context of the current connection (http://redis.io/commands/wait). Since Redis 3.0.0

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

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

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

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

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

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

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

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

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

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

Incrementally iterate hash fields and associated values (http://redis.io/commands/hscan). The Redis command HSCAN is split up into hscan, hscanOpts. Since Redis 2.8.0

Incrementally iterate hash fields and associated values (http://redis.io/commands/hscan). The Redis command HSCAN is split up into hscan, hscanOpts. Since Redis 2.8.0

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

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

Get the length of the value of a hash field (http://redis.io/commands/hstrlen). Since Redis 3.2.0

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

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

Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s) (http://redis.io/commands/pfcount). Since Redis 2.8.9

Merge N different HyperLogLogs into a single one (http://redis.io/commands/pfmerge). Since Redis 2.8.9

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Set the debug mode for executed scripts (http://redis.io/commands/script-debug). Since Redis 3.2.0

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

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

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

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

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

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

Get the current connection name (http://redis.io/commands/client-getname). Since Redis 2.6.9

Get the list of client connections (http://redis.io/commands/client-list). Since Redis 2.4.0

Stop processing commands from clients for some time (http://redis.io/commands/client-pause). Since Redis 2.9.50

Instruct the server whether to reply to commands (http://redis.io/commands/client-reply). Since Redis 3.2

Set the current connection name (http://redis.io/commands/client-setname). Since Redis 2.6.9

Get total number of Redis commands (http://redis.io/commands/command-count). Since Redis 2.8.13

Get array of specific Redis command details (http://redis.io/commands/command-info). Since Redis 2.8.13

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

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

Rewrite the configuration file with the in memory configuration (http://redis.io/commands/config-rewrite). Since Redis 2.8.0

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

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

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

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

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

Get information and statistics about the server (http://redis.io/commands/info). The Redis command INFO is split up into info, infoSection. Since Redis 1.0.0

Get information and statistics about the server (http://redis.io/commands/info). The Redis command INFO is split up into info, infoSection. Since Redis 1.0.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Remove and return one or multiple random members from a set (http://redis.io/commands/spop). The Redis command SPOP is split up into spop, spopN. Since Redis 1.0.0

Remove and return one or multiple random members from a set (http://redis.io/commands/spop). The Redis command SPOP is split up into spop, spopN. Since Redis 1.0.0

Get one or multiple random members from a set (http://redis.io/commands/srandmember). The Redis command SRANDMEMBER is split up into srandmember, srandmemberN. Since Redis 1.0.0

Get one or multiple random members from a set (http://redis.io/commands/srandmember). The Redis command SRANDMEMBER is split up into srandmember, srandmemberN. Since Redis 1.0.0

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

Incrementally iterate Set elements (http://redis.io/commands/sscan). The Redis command SSCAN is split up into sscan, sscanOpts. Since Redis 2.8.0

Incrementally iterate Set elements (http://redis.io/commands/sscan). The Redis command SSCAN is split up into sscan, sscanOpts. Since Redis 2.8.0

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

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

Add one or more members to a sorted set, or update its score if it already exists (http://redis.io/commands/zadd). The Redis command ZADD is split up into zadd, zaddOpts. Since Redis 1.2.0

Add one or more members to a sorted set, or update its score if it already exists (http://redis.io/commands/zadd). The Redis command ZADD is split up into zadd, zaddOpts. Since Redis 1.2.0

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

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

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

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

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

Count the number of members in a sorted set between a given lexicographical range (http://redis.io/commands/zlexcount). Since Redis 2.8.9

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

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

Return a range of members in a sorted set, by lexicographical range (http://redis.io/commands/zrangebylex). Since Redis 2.8.9