Imm.Database

DSL/interpreter model for a generic key-value database

DSL/interpreter

class (Ord (Key t), Show (Key t), Show (Entry t), Typeable t, Show t, Pretty t, Pretty (Key t), Pretty (Entry t)) => Table t

Generic database table

Associated Types

type Key t :: *

type Entry t :: *

Instances

Table FeedTable

Associated Types

type Key FeedTable :: *

type Entry FeedTable :: *

data DatabaseF t next

Database DSL

Constructors

FetchList t [Key t] (Either SomeException (Map (Key t) (Entry t)) -> next)

FetchAll t (Either SomeException (Map (Key t) (Entry t)) -> next)

Update t (Key t) (Entry t -> Entry t) (Either SomeException () -> next)

InsertList t [(Key t, Entry t)] (Either SomeException () -> next)

DeleteList t [Key t] (Either SomeException () -> next)

Purge t (Either SomeException () -> next)

Commit t (Either SomeException () -> next)

Instances

Functor (DatabaseF t)

Methods

fmap :: (a -> b) -> DatabaseF t a -> DatabaseF t b

(<$) :: a -> DatabaseF t b -> DatabaseF t a

Monad m => PairingM (CoDatabaseF t m) (DatabaseF t) m

Methods

pairM :: (a -> b -> m r) -> CoDatabaseF t m a -> DatabaseF t b -> m r

data CoDatabaseF t m a

Database interpreter

Constructors

CoDatabaseF

Fields

• fetchListH :: [Key t] -> m (Either SomeException (Map (Key t) (Entry t)), a)
• fetchAllH :: m (Either SomeException (Map (Key t) (Entry t)), a)
• updateH :: Key t -> (Entry t -> Entry t) -> m (Either SomeException (), a)
• insertListH :: [(Key t, Entry t)] -> m (Either SomeException (), a)
• deleteListH :: [Key t] -> m (Either SomeException (), a)
• purgeH :: m (Either SomeException (), a)
• commitH :: m (Either SomeException (), a)

Instances

Functor m => Functor (CoDatabaseF t m)

Methods

fmap :: (a -> b) -> CoDatabaseF t m a -> CoDatabaseF t m b

(<$) :: a -> CoDatabaseF t m b -> CoDatabaseF t m a

Monad m => PairingM (CoDatabaseF t m) (DatabaseF t) m

Methods

pairM :: (a -> b -> m r) -> CoDatabaseF t m a -> DatabaseF t b -> m r

Exception

data DatabaseException t

Constructors

NotCommitted t

NotDeleted t [Key t]

NotFound t [Key t]

NotInserted t [(Key t, Entry t)]

NotPurged t

NotUpdated t (Key t)

UnableFetchAll t

Instances

(Eq t, Eq (Key t), Eq (Entry t)) => Eq (DatabaseException t)

Methods

(==) :: DatabaseException t -> DatabaseException t -> Bool

(/=) :: DatabaseException t -> DatabaseException t -> Bool

(Show t, Show (Key t), Show (Entry t)) => Show (DatabaseException t)

Methods

showsPrec :: Int -> DatabaseException t -> ShowS

show :: DatabaseException t -> String

showList :: [DatabaseException t] -> ShowS

(Pretty t, Pretty (Key t)) => Pretty (DatabaseException t)

Methods

pretty :: DatabaseException t -> Doc

prettyList :: [DatabaseException t] -> Doc

(Table t, Show (Key t), Show (Entry t), Pretty (Key t), Typeable * t) => Exception (DatabaseException t)

Methods

toException :: DatabaseException t -> SomeException

fromException :: SomeException -> Maybe (DatabaseException t)

displayException :: DatabaseException t -> String

Primitives

fetch :: (Functor f, MonadFree f m, DatabaseF t :<: f, Table t, MonadThrow m) => t -> Key t -> m (Entry t)

fetchList :: (Functor f, MonadFree f m, DatabaseF t :<: f, Table t, MonadThrow m) => t -> [Key t] -> m (Map (Key t) (Entry t))

fetchAll :: (MonadThrow m, Functor f, MonadFree f m, DatabaseF t :<: f, Table t) => t -> m (Map (Key t) (Entry t))

update :: (Functor f, MonadFree f m, DatabaseF t :<: f, Table t, MonadThrow m) => t -> Key t -> (Entry t -> Entry t) -> m ()

insert :: (MonadThrow m, Functor f, MonadFree f m, LoggerF :<: f, DatabaseF t :<: f, Table t) => t -> Key t -> Entry t -> m ()

insertList :: (MonadThrow m, Functor f, MonadFree f m, LoggerF :<: f, DatabaseF t :<: f, Table t) => t -> [(Key t, Entry t)] -> m ()

delete :: (MonadThrow m, Functor f, MonadFree f m, LoggerF :<: f, DatabaseF t :<: f, Table t) => t -> Key t -> m ()

deleteList :: (MonadThrow m, Functor f, MonadFree f m, LoggerF :<: f, DatabaseF t :<: f, Table t) => t -> [Key t] -> m ()

purge :: (MonadThrow m, Functor f, MonadFree f m, DatabaseF t :<: f, LoggerF :<: f, Table t) => t -> m ()

commit :: (MonadThrow m, Functor f, MonadFree f m, DatabaseF t :<: f, LoggerF :<: f, Table t) => t -> m ()