Database.Redis.Monad

Monadic wrapper for Database.Redis.Redis

Types ans Constructors

class MonadIO m => WithRedis m where

Methods

getRedis :: m Redis

setRedis :: Redis -> m ()

Instances

WithRedis RedisM

data Redis

Redis connection descriptor

Constructors

Redis

Fields

server :: (String, String)

hostname and port pair

handle :: Handle

real network connection

Instances

Eq Redis

Show Redis

data BS s => Reply s

Redis reply variants

Constructors

RTimeout

Timeout. Currently unused

ROk

"Ok" reply

RPong

Reply for the ping command

RQueued

Used inside multi-exec block

RError String

Some kind of server-side error

RInline s

Simple oneline reply

RInt Int

Integer reply

RBulk (Maybe s)

Multiline reply

RMulti (Maybe [Reply s])

Complex reply. It may consists of various type of replys

Instances

(Eq s, BS s) => Eq (Reply s)

BS s => Show (Reply s)

data Interval a

Interval representation

Constructors

Closed a a

closed interval [a, b]

Open a a

open interval (a, b)

LeftOpen a a

left-open interval (a, b]

RightOpen a a

right-open interval [a, b)

Instances

Show a => Show (Interval a)

IsInterval (Interval a) a

Trivial IsInterval instance

class IsInterval i a | i -> a where

Class for conversion value to Interval

Definied instances is:

• the Interval itself
• pair (a,b) for open interval
• two-member list [a, b] for closed interval (throws runtime error if the list length is different)

Methods

toInterval :: i -> Interval a

Instances

IsInterval [a] a

Two-element list [a, b] converted to closed interval. No static checking of list length performed.

IsInterval (Interval a) a

Trivial IsInterval instance

IsInterval (a, a) a

Pair (a, b) converted to open interval

data BS s => SortOptions s

Options data type for the sort command

Constructors

SortOptions

Fields

desc :: Bool

sort with descending order

limit :: (Int, Int)

return (from, to) elements

alpha :: Bool

sort alphabetically

sort_by :: s

sort by value from this key

get_obj :: [s]

return this keys values

store :: s

store result to this key

sortDefaults :: SortOptions ByteString

Default options for the sort command

fromRInline :: (Monad m, BS s) => Reply s -> m s

Unwraps RInline reply.

Throws an exception when called with something different from RInline

fromRBulk :: (Monad m, BS s) => Reply s -> m (Maybe s)

Unwraps RBulk reply.

Throws an exception when called with something different from RBulk

fromRMulti :: (Monad m, BS s) => Reply s -> m (Maybe [Reply s])

Unwraps RMulti reply

Throws an exception when called with something different from RMulti

fromRMultiBulk :: (Monad m, BS s) => Reply s -> m (Maybe [Maybe s])

Unwraps RMulti reply filled with RBulk

Throws an exception when called with something different from RMulti

fromRInt :: (Monad m, BS s) => Reply s -> m Int

Unwraps RInt reply

Throws an exception when called with something different from RInt

fromROk :: (Monad m, BS s) => Reply s -> m ()

Unwraps ROk reply

Throws an exception when called with something different from ROk

noError :: (Monad m, BS s) => Reply s -> m ()

Unwraps every non-error reply

Throws an exception when called with something different from RMulti

takeAll :: (Int, Int)

a (0, -1) range - takes all element from a list in lrange, zrange and so on

Database connection

localhost :: String

just a localhost

defaultPort :: String

default Redis port

connect :: WithRedis m => String -> String -> m ()

disconnect :: WithRedis m => m ()

isConnected :: WithRedis m => m Bool

Redis commands

Generic

ping :: WithRedis m => m (Reply ())

auth :: WithRedis m => String -> m (Reply ())

quit :: WithRedis m => m ()

shutdown :: WithRedis m => m ()

multi :: WithRedis m => m (Reply ())

exec :: (WithRedis m, BS s) => m (Reply s)

discard :: WithRedis m => m (Reply ())

run_multi :: (WithRedis m, BS s) => [m (Reply ())] -> m (Reply s)

exists :: (WithRedis m, BS s) => s -> m (Reply Int)

del :: (WithRedis m, BS s) => s -> m (Reply Int)

getType :: (WithRedis m, BS s1, BS s2) => s1 -> m (Reply s2)

keys :: (WithRedis m, BS s1, BS s2) => s1 -> m (Reply s2)

randomKey :: (WithRedis m, BS s) => m (Reply s)

rename :: (WithRedis m, BS s1, BS s2) => s1 -> s2 -> m (Reply ())

renameNx :: (WithRedis m, BS s1, BS s2) => s1 -> s2 -> m (Reply Int)

dbsize :: WithRedis m => m (Reply Int)

expire :: (WithRedis m, BS s) => s -> Int -> m (Reply Int)

expireAt :: (WithRedis m, BS s) => s -> Int -> m (Reply Int)

ttl :: (WithRedis m, BS s) => s -> m (Reply Int)

select :: WithRedis m => Int -> m (Reply ())

move :: (WithRedis m, BS s) => s -> Int -> m (Reply Int)

flushDb :: WithRedis m => m (Reply ())

flushAll :: WithRedis m => m (Reply ())

info :: (WithRedis m, BS s) => m (Reply s)

Strings

set :: (WithRedis m, BS s1, BS s2) => s1 -> s2 -> m (Reply ())

setNx :: (WithRedis m, BS s1, BS s2) => s1 -> s2 -> m (Reply Int)

mSet :: (WithRedis m, BS s1, BS s2) => [(s1, s2)] -> m (Reply ())

mSetNx :: (WithRedis m, BS s1, BS s2) => [(s1, s2)] -> m (Reply Int)

get :: (WithRedis m, BS s1, BS s2) => s1 -> m (Reply s2)

getSet :: (WithRedis m, BS s1, BS s2, BS s3) => s1 -> s2 -> m (Reply s3)

mGet :: (WithRedis m, BS s1, BS s2) => [s1] -> m (Reply s2)

incr :: (WithRedis m, BS s) => s -> m (Reply Int)

incrBy :: (WithRedis m, BS s) => s -> Int -> m (Reply Int)

decr :: (WithRedis m, BS s) => s -> m (Reply Int)

decrBy :: (WithRedis m, BS s) => s -> Int -> m (Reply Int)

append :: (WithRedis m, BS s1, BS s2) => s1 -> s2 -> m (Reply Int)

substr :: (WithRedis m, BS s1, BS s2) => s1 -> (Int, Int) -> m (Reply s2)

Lists

rpush :: (WithRedis m, BS s1, BS s2) => s1 -> s2 -> m (Reply Int)

lpush :: (WithRedis m, BS s1, BS s2) => s1 -> s2 -> m (Reply Int)

llen :: (WithRedis m, BS s) => s -> m (Reply Int)

lrange :: (WithRedis m, BS s1, BS s2) => s1 -> (Int, Int) -> m (Reply s2)

ltrim :: (WithRedis m, BS s) => s -> (Int, Int) -> m (Reply ())

lindex :: (WithRedis m, BS s1, BS s2) => s1 -> Int -> m (Reply s2)

lset :: (WithRedis m, BS s1, BS s2) => s1 -> Int -> s2 -> m (Reply ())

lrem :: (WithRedis m, BS s1, BS s2) => s1 -> Int -> s2 -> m (Reply Int)

lpop :: (WithRedis m, BS s1, BS s2) => s1 -> m (Reply s2)

rpop :: (WithRedis m, BS s1, BS s2) => s1 -> m (Reply s2)

rpoplpush :: (WithRedis m, BS s1, BS s2, BS s3) => s1 -> s2 -> m (Reply s3)

blpop :: (WithRedis m, BS s1, BS s2) => [s1] -> Int -> m (Reply s2)

brpop :: (WithRedis m, BS s1, BS s2) => [s1] -> Int -> m (Reply s2)

Sets

sadd :: (WithRedis m, BS s1, BS s2) => s1 -> s2 -> m (Reply Int)

srem :: (WithRedis m, BS s1, BS s2) => s1 -> s2 -> m (Reply Int)

spop :: (WithRedis m, BS s1, BS s2) => s1 -> m (Reply s2)

smove :: (WithRedis m, BS s1, BS s2, BS s3) => s1 -> s2 -> s3 -> m (Reply Int)

scard :: (WithRedis m, BS s) => s -> m (Reply Int)

sismember :: (WithRedis m, BS s) => s -> m (Reply Int)

smembers :: (WithRedis m, BS s1, BS s2) => s1 -> m (Reply s2)

srandmember :: (WithRedis m, BS s1, BS s2) => s1 -> m (Reply s2)

sinter :: (WithRedis m, BS s1, BS s2) => [s1] -> m (Reply s2)

sinterStore :: (WithRedis m, BS s1, BS s2) => s1 -> [s2] -> m (Reply ())

sunion :: (WithRedis m, BS s1, BS s2) => [s1] -> m (Reply s2)

sunionStore :: (WithRedis m, BS s1, BS s2) => s1 -> [s2] -> m (Reply ())

sdiff :: (WithRedis m, BS s1, BS s2) => [s1] -> m (Reply s2)

sdiffStore :: (WithRedis m, BS s1, BS s2) => s1 -> [s2] -> m (Reply ())

Sorted sets

zadd :: (WithRedis m, BS s1, BS s2) => s1 -> Double -> s2 -> m (Reply Int)

zrem :: (WithRedis m, BS s1, BS s2) => s1 -> s2 -> m (Reply Int)

zincrBy :: (WithRedis m, BS s1, BS s2, BS s3) => s1 -> Double -> s2 -> m (Reply s3)

zrange :: (WithRedis m, BS s1, BS s2) => s1 -> (Int, Int) -> Bool -> m (Reply s2)

zrevrange :: (WithRedis m, BS s1, BS s2) => s1 -> (Int, Int) -> Bool -> m (Reply s2)

zrangebyscore :: (WithRedis m, IsInterval i Double, BS s1, BS s2) => s1 -> i -> Bool -> m (Reply s2)

zcount :: (WithRedis m, IsInterval i Double, BS s) => s -> i -> m (Reply Int)

zremrangebyscore :: (WithRedis m, BS s) => s -> (Double, Double) -> m (Reply Int)

zcard :: (WithRedis m, BS s) => s -> m (Reply Int)

zscore :: (WithRedis m, BS s1, BS s2, BS s3) => s1 -> s2 -> m (Reply s3)

zrank :: (WithRedis m, BS s1, BS s2) => s1 -> s2 -> m (Reply Int)

Sorting

sort :: (WithRedis m, BS s1, BS s2, BS s3) => s1 -> SortOptions s2 -> m (Reply s3)

listRelated :: (WithRedis m, BS s1, BS s2, BS s3) => s1 -> s2 -> (Int, Int) -> m (Reply s3)

Persistent control

save :: WithRedis m => m (Reply ())

bgsave :: WithRedis m => m (Reply ())

lastsave :: WithRedis m => m (Reply Int)

bgrewriteaof :: WithRedis m => m (Reply ())