Safe Haskell	None
Language	Haskell2010

Control.Monad.Haskey

Contents

Re-exports
Monad
Open and create (re-exports)

Description

A monad transformer supporting Haskey transactions.

See https://github.com/haskell-haskey/haskey-mtl/blob/master/example/Main.hs for a complete example.

Synopsis

module Database.Haskey.Alloc.Transaction
class Monad m => MonadHaskey root m | m -> root where
data HaskeyT root m a
runHaskeyT :: (Root root, MonadMask m, MonadIO m) => HaskeyT root m a -> ConcurrentDb root -> FileStoreConfig -> m a
data FileStoreT fp (m :: * -> *) a
data FileStoreConfig
runFileStoreT :: Monad m => FileStoreT FilePath m a -> FileStoreConfig -> m a
defFileStoreConfig :: FileStoreConfig
data ConcurrentDb root
concurrentHandles :: FilePath -> ConcurrentHandles
openConcurrentDb :: (Root root, MonadIO m, MonadMask m, ConcurrentMetaStoreM m) => ConcurrentHandles -> m (Maybe (ConcurrentDb root))
createConcurrentDb :: (Root root, MonadIO m, MonadMask m, ConcurrentMetaStoreM m) => ConcurrentHandles -> root -> m (ConcurrentDb root)

Re-exports

module Database.Haskey.Alloc.Transaction

Monad

class Monad m => MonadHaskey root m | m -> root where #

A monad supporting database transactions.

The type root is the data type holding the roots of the database trees.

Minimal complete definition

transact, transact_, transactReadOnly

Methods

transact :: Root root => (forall n. (AllocM n, MonadMask n) => root -> n (Transaction root a)) -> m a #

transact_ :: Root root => (forall n. (AllocM n, MonadMask n) => root -> n (Transaction root ())) -> m () #

transactReadOnly :: Root root => (forall n. (AllocReaderM n, MonadMask n) => root -> n a) -> m a #

Instances

(Monoid w, MonadHaskey root m) => MonadHaskey root (WriterT w m) #
Instance details Defined in Control.Monad.Haskey Methods transact :: Root root => (forall (n :: * -> ). (AllocM n, MonadMask n) => root -> n (Transaction root a)) -> WriterT w m a # transact_ :: (forall (n :: -> ). (AllocM n, MonadMask n) => root -> n (Transaction root ())) -> WriterT w m () # transactReadOnly :: Root root => (forall (n :: -> *). (AllocReaderM n, MonadMask n) => root -> n a) -> WriterT w m a #
(Monoid w, MonadHaskey root m) => MonadHaskey root (WriterT w m) #
Instance details Defined in Control.Monad.Haskey Methods transact :: Root root => (forall (n :: * -> ). (AllocM n, MonadMask n) => root -> n (Transaction root a)) -> WriterT w m a # transact_ :: (forall (n :: -> ). (AllocM n, MonadMask n) => root -> n (Transaction root ())) -> WriterT w m () # transactReadOnly :: Root root => (forall (n :: -> *). (AllocReaderM n, MonadMask n) => root -> n a) -> WriterT w m a #
MonadHaskey root m => MonadHaskey root (StateT s m) #
Instance details Defined in Control.Monad.Haskey Methods transact :: Root root => (forall (n :: * -> ). (AllocM n, MonadMask n) => root -> n (Transaction root a)) -> StateT s m a # transact_ :: (forall (n :: -> ). (AllocM n, MonadMask n) => root -> n (Transaction root ())) -> StateT s m () # transactReadOnly :: Root root => (forall (n :: -> *). (AllocReaderM n, MonadMask n) => root -> n a) -> StateT s m a #
MonadHaskey root m => MonadHaskey root (StateT s m) #
Instance details Defined in Control.Monad.Haskey Methods transact :: Root root => (forall (n :: * -> ). (AllocM n, MonadMask n) => root -> n (Transaction root a)) -> StateT s m a # transact_ :: (forall (n :: -> ). (AllocM n, MonadMask n) => root -> n (Transaction root ())) -> StateT s m () # transactReadOnly :: Root root => (forall (n :: -> *). (AllocReaderM n, MonadMask n) => root -> n a) -> StateT s m a #
(Root root, Applicative m, MonadMask m, MonadIO m) => MonadHaskey root (HaskeyT root m) #
Instance details Defined in Control.Monad.Haskey Methods transact :: Root root => (forall (n :: * -> ). (AllocM n, MonadMask n) => root -> n (Transaction root a)) -> HaskeyT root m a # transact_ :: (forall (n :: -> ). (AllocM n, MonadMask n) => root -> n (Transaction root ())) -> HaskeyT root m () # transactReadOnly :: Root root => (forall (n :: -> *). (AllocReaderM n, MonadMask n) => root -> n a) -> HaskeyT root m a #
MonadHaskey root m => MonadHaskey root (ReaderT r m) #
Instance details Defined in Control.Monad.Haskey Methods transact :: Root root => (forall (n :: * -> ). (AllocM n, MonadMask n) => root -> n (Transaction root a)) -> ReaderT r m a # transact_ :: (forall (n :: -> ). (AllocM n, MonadMask n) => root -> n (Transaction root ())) -> ReaderT r m () # transactReadOnly :: Root root => (forall (n :: -> *). (AllocReaderM n, MonadMask n) => root -> n a) -> ReaderT r m a #
(Monoid w, MonadHaskey root m) => MonadHaskey root (RWST r w s m) #
Instance details Defined in Control.Monad.Haskey Methods transact :: Root root => (forall (n :: * -> ). (AllocM n, MonadMask n) => root -> n (Transaction root a)) -> RWST r w s m a # transact_ :: (forall (n :: -> ). (AllocM n, MonadMask n) => root -> n (Transaction root ())) -> RWST r w s m () # transactReadOnly :: Root root => (forall (n :: -> *). (AllocReaderM n, MonadMask n) => root -> n a) -> RWST r w s m a #
(Monoid w, MonadHaskey root m) => MonadHaskey root (RWST r w s m) #
Instance details Defined in Control.Monad.Haskey Methods transact :: Root root => (forall (n :: * -> ). (AllocM n, MonadMask n) => root -> n (Transaction root a)) -> RWST r w s m a # transact_ :: (forall (n :: -> ). (AllocM n, MonadMask n) => root -> n (Transaction root ())) -> RWST r w s m () # transactReadOnly :: Root root => (forall (n :: -> *). (AllocReaderM n, MonadMask n) => root -> n a) -> RWST r w s m a #

data HaskeyT root m a #

A monad transformer that is an instance of MonadHaskey.

The root is the data type holding the roots of the database trees.

Instances

MonadRWS r w s m => MonadRWS r w s (HaskeyT root m) #
Instance details Defined in Control.Monad.Haskey
MonadBaseControl IO m => MonadBaseControl IO (HaskeyT root m) #
Instance details Defined in Control.Monad.Haskey Associated Types type StM (HaskeyT root m) a :: * # Methods liftBaseWith :: (RunInBase (HaskeyT root m) IO -> IO a) -> HaskeyT root m a # restoreM :: StM (HaskeyT root m) a -> HaskeyT root m a #
MonadBase IO m => MonadBase IO (HaskeyT root m) #
Instance details Defined in Control.Monad.Haskey Methods liftBase :: IO α -> HaskeyT root m α #
MonadWriter w m => MonadWriter w (HaskeyT root m) #
Instance details Defined in Control.Monad.Haskey Methods writer :: (a, w) -> HaskeyT root m a # tell :: w -> HaskeyT root m () # listen :: HaskeyT root m a -> HaskeyT root m (a, w) # pass :: HaskeyT root m (a, w -> w) -> HaskeyT root m a #
MonadState s m => MonadState s (HaskeyT root m) #
Instance details Defined in Control.Monad.Haskey Methods get :: HaskeyT root m s # put :: s -> HaskeyT root m () # state :: (s -> (a, s)) -> HaskeyT root m a #
MonadReader r m => MonadReader r (HaskeyT root m) #
Instance details Defined in Control.Monad.Haskey Methods ask :: HaskeyT root m r # local :: (r -> r) -> HaskeyT root m a -> HaskeyT root m a # reader :: (r -> a) -> HaskeyT root m a #
(Root root, Applicative m, MonadMask m, MonadIO m) => MonadHaskey root (HaskeyT root m) #
Instance details Defined in Control.Monad.Haskey Methods transact :: Root root => (forall (n :: * -> ). (AllocM n, MonadMask n) => root -> n (Transaction root a)) -> HaskeyT root m a # transact_ :: (forall (n :: -> ). (AllocM n, MonadMask n) => root -> n (Transaction root ())) -> HaskeyT root m () # transactReadOnly :: Root root => (forall (n :: -> *). (AllocReaderM n, MonadMask n) => root -> n a) -> HaskeyT root m a #
MonadTransControl (HaskeyT root) #
Instance details Defined in Control.Monad.Haskey Associated Types type StT (HaskeyT root) a :: * # Methods liftWith :: Monad m => (Run (HaskeyT root) -> m a) -> HaskeyT root m a # restoreT :: Monad m => m (StT (HaskeyT root) a) -> HaskeyT root m a #
MonadTrans (HaskeyT root) #
Instance details Defined in Control.Monad.Haskey Methods lift :: Monad m => m a -> HaskeyT root m a #
Monad m => Monad (HaskeyT root m) #
Instance details Defined in Control.Monad.Haskey Methods (>>=) :: HaskeyT root m a -> (a -> HaskeyT root m b) -> HaskeyT root m b # (>>) :: HaskeyT root m a -> HaskeyT root m b -> HaskeyT root m b # return :: a -> HaskeyT root m a # fail :: String -> HaskeyT root m a #
Functor m => Functor (HaskeyT root m) #
Instance details Defined in Control.Monad.Haskey Methods fmap :: (a -> b) -> HaskeyT root m a -> HaskeyT root m b # (<$) :: a -> HaskeyT root m b -> HaskeyT root m a #
Applicative m => Applicative (HaskeyT root m) #
Instance details Defined in Control.Monad.Haskey Methods pure :: a -> HaskeyT root m a # (<>) :: HaskeyT root m (a -> b) -> HaskeyT root m a -> HaskeyT root m b # liftA2 :: (a -> b -> c) -> HaskeyT root m a -> HaskeyT root m b -> HaskeyT root m c # (>) :: HaskeyT root m a -> HaskeyT root m b -> HaskeyT root m b # (<*) :: HaskeyT root m a -> HaskeyT root m b -> HaskeyT root m a #
MonadIO m => MonadIO (HaskeyT root m) #
Instance details Defined in Control.Monad.Haskey Methods liftIO :: IO a -> HaskeyT root m a #
MonadThrow m => MonadThrow (HaskeyT root m) #
Instance details Defined in Control.Monad.Haskey Methods throwM :: Exception e => e -> HaskeyT root m a #
MonadCatch m => MonadCatch (HaskeyT root m) #
Instance details Defined in Control.Monad.Haskey Methods catch :: Exception e => HaskeyT root m a -> (e -> HaskeyT root m a) -> HaskeyT root m a #
MonadMask m => MonadMask (HaskeyT root m) #
Instance details Defined in Control.Monad.Haskey Methods mask :: ((forall a. HaskeyT root m a -> HaskeyT root m a) -> HaskeyT root m b) -> HaskeyT root m b # uninterruptibleMask :: ((forall a. HaskeyT root m a -> HaskeyT root m a) -> HaskeyT root m b) -> HaskeyT root m b # generalBracket :: HaskeyT root m a -> (a -> ExitCase b -> HaskeyT root m c) -> (a -> HaskeyT root m b) -> HaskeyT root m (b, c) #
type StT (HaskeyT root) a #
Instance details Defined in Control.Monad.Haskey type StT (HaskeyT root) a = StT (ReaderT (ConcurrentDb root, FileStoreConfig) :: (* -> ) -> -> *) a
type StM (HaskeyT root m) a #
Instance details Defined in Control.Monad.Haskey type StM (HaskeyT root m) a = ComposeSt (HaskeyT root) m a

runHaskeyT :: (Root root, MonadMask m, MonadIO m) => HaskeyT root m a -> ConcurrentDb root -> FileStoreConfig -> m a #

Run Haskey transactions, backed by a file store.

Open and create (re-exports)

data FileStoreT fp (m :: * -> *) a #

Monad in which on-disk storage operations can take place.

Two important instances are StoreM making it a storage back-end, and ConcurrentMetaStoreM making it a storage back-end compatible with the concurrent page allocator.

Instances

(Applicative m, Monad m, MonadIO m, MonadThrow m) => StoreM FilePath (FileStoreT FilePath m)
Instance details Defined in Database.Haskey.Store.File Methods openHandle :: FilePath -> FileStoreT FilePath m () # lockHandle :: FilePath -> FileStoreT FilePath m () # releaseHandle :: FilePath -> FileStoreT FilePath m () # flushHandle :: FilePath -> FileStoreT FilePath m () # closeHandle :: FilePath -> FileStoreT FilePath m () # removeHandle :: FilePath -> FileStoreT FilePath m () # nodePageSize :: (Key key, Value val) => FileStoreT FilePath m (Height height -> Node height key val -> PageSize) # maxPageSize :: FileStoreT FilePath m PageSize # maxKeySize :: FileStoreT FilePath m Word64 # maxValueSize :: FileStoreT FilePath m Word64 # getNodePage :: (Key key, Value val) => FilePath -> Height height -> Proxy key -> Proxy val -> NodeId height key val -> FileStoreT FilePath m (Node height key val) # putNodePage :: (Key key, Value val) => FilePath -> Height height -> NodeId height key val -> Node height key val -> FileStoreT FilePath m () # getOverflow :: Value val => FilePath -> Proxy val -> FileStoreT FilePath m val # putOverflow :: Value val => FilePath -> val -> FileStoreT FilePath m () # listOverflows :: FilePath -> FileStoreT FilePath m [FilePath] #
Monad m => MonadReader FileStoreConfig (FileStoreT fp m)
Instance details Defined in Database.Haskey.Store.File Methods ask :: FileStoreT fp m FileStoreConfig # local :: (FileStoreConfig -> FileStoreConfig) -> FileStoreT fp m a -> FileStoreT fp m a # reader :: (FileStoreConfig -> a) -> FileStoreT fp m a #
Monad m => MonadState (Files fp) (FileStoreT fp m)
Instance details Defined in Database.Haskey.Store.File Methods get :: FileStoreT fp m (Files fp) # put :: Files fp -> FileStoreT fp m () # state :: (Files fp -> (a, Files fp)) -> FileStoreT fp m a #
Monad m => Monad (FileStoreT fp m)
Instance details Defined in Database.Haskey.Store.File Methods (>>=) :: FileStoreT fp m a -> (a -> FileStoreT fp m b) -> FileStoreT fp m b # (>>) :: FileStoreT fp m a -> FileStoreT fp m b -> FileStoreT fp m b # return :: a -> FileStoreT fp m a # fail :: String -> FileStoreT fp m a #
Functor m => Functor (FileStoreT fp m)
Instance details Defined in Database.Haskey.Store.File Methods fmap :: (a -> b) -> FileStoreT fp m a -> FileStoreT fp m b # (<$) :: a -> FileStoreT fp m b -> FileStoreT fp m a #
Monad m => Applicative (FileStoreT fp m)
Instance details Defined in Database.Haskey.Store.File Methods pure :: a -> FileStoreT fp m a # (<>) :: FileStoreT fp m (a -> b) -> FileStoreT fp m a -> FileStoreT fp m b # liftA2 :: (a -> b -> c) -> FileStoreT fp m a -> FileStoreT fp m b -> FileStoreT fp m c # (>) :: FileStoreT fp m a -> FileStoreT fp m b -> FileStoreT fp m b # (<*) :: FileStoreT fp m a -> FileStoreT fp m b -> FileStoreT fp m a #
MonadIO m => MonadIO (FileStoreT fp m)
Instance details Defined in Database.Haskey.Store.File Methods liftIO :: IO a -> FileStoreT fp m a #
MonadThrow m => MonadThrow (FileStoreT fp m)
Instance details Defined in Database.Haskey.Store.File Methods throwM :: Exception e => e -> FileStoreT fp m a #
MonadCatch m => MonadCatch (FileStoreT fp m)
Instance details Defined in Database.Haskey.Store.File Methods catch :: Exception e => FileStoreT fp m a -> (e -> FileStoreT fp m a) -> FileStoreT fp m a #
MonadMask m => MonadMask (FileStoreT fp m)
Instance details Defined in Database.Haskey.Store.File Methods mask :: ((forall a. FileStoreT fp m a -> FileStoreT fp m a) -> FileStoreT fp m b) -> FileStoreT fp m b # uninterruptibleMask :: ((forall a. FileStoreT fp m a -> FileStoreT fp m a) -> FileStoreT fp m b) -> FileStoreT fp m b # generalBracket :: FileStoreT fp m a -> (a -> ExitCase b -> FileStoreT fp m c) -> (a -> FileStoreT fp m b) -> FileStoreT fp m (b, c) #
(Applicative m, Monad m, MonadIO m, MonadCatch m) => ConcurrentMetaStoreM (FileStoreT FilePath m)
Instance details Defined in Database.Haskey.Store.File Methods putConcurrentMeta :: Root root => FilePath -> ConcurrentMeta root -> FileStoreT FilePath m () # readConcurrentMeta :: Root root => FilePath -> Proxy root -> FileStoreT FilePath m (Maybe (ConcurrentMeta root)) #

data FileStoreConfig #

File store configuration.

The default configuration can be obtained by using defFileStoreConfig

A configuration with a specific page size can be obtained by using fileStoreConfigWithPageSize.

Instances

Show FileStoreConfig
Instance details Defined in Database.Haskey.Store.File Methods showsPrec :: Int -> FileStoreConfig -> ShowS # show :: FileStoreConfig -> String # showList :: [FileStoreConfig] -> ShowS #
Monad m => MonadReader FileStoreConfig (FileStoreT fp m)
Instance details Defined in Database.Haskey.Store.File Methods ask :: FileStoreT fp m FileStoreConfig # local :: (FileStoreConfig -> FileStoreConfig) -> FileStoreT fp m a -> FileStoreT fp m a # reader :: (FileStoreConfig -> a) -> FileStoreT fp m a #

runFileStoreT #

Arguments

:: Monad m
=> FileStoreT FilePath m a	Action
-> FileStoreConfig	Configuration
-> m a

Run the storage operations in the FileStoreT monad, given a collection of open files.

defFileStoreConfig :: FileStoreConfig #

The default configuration

This is an unwrapped fileStoreConfigWithPageSize with a page size of 4096 bytes.

data ConcurrentDb root #

An active concurrent database.

This can be shared amongst threads.

concurrentHandles :: FilePath -> ConcurrentHandles #

Construct a set of ConcurrentHandles from a root directory.

openConcurrentDb :: (Root root, MonadIO m, MonadMask m, ConcurrentMetaStoreM m) => ConcurrentHandles -> m (Maybe (ConcurrentDb root)) #

Open the an existing database, with the given handles.

createConcurrentDb :: (Root root, MonadIO m, MonadMask m, ConcurrentMetaStoreM m) => ConcurrentHandles -> root -> m (ConcurrentDb root) #

Open a new concurrent database, with the given handles.