-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | A monad transformer supporting Haskey transactions.
--   
--   This library provides a monad transformer supporting Haskey
--   transactions, with default lifted instances for all mtl monad
--   transformers.
--   
--   For more information on how to use this package, visit
--   <a>https://github.com/haskell-haskey/haskey-mtl</a>
@package haskey-mtl
@version 0.3.1.0


-- | A monad transformer supporting Haskey transactions.
--   
--   See
--   <a>https://github.com/haskell-haskey/haskey-mtl/blob/master/example/Main.hs</a>
--   for a complete example.
module Control.Monad.Haskey

-- | A monad supporting database transactions.
--   
--   The type <tt>root</tt> is the data type holding the roots of the
--   database trees.
class Monad m => MonadHaskey root m | m -> root
transact :: (MonadHaskey root m, Root root) => (forall n. (AllocM n, MonadMask n) => root -> n (Transaction root a)) -> m a
transact_ :: (MonadHaskey root m, Root root) => (forall n. (AllocM n, MonadMask n) => root -> n (Transaction root ())) -> m ()
transactReadOnly :: (MonadHaskey root m, Root root) => (forall n. (AllocReaderM n, MonadMask n) => root -> n a) -> m a

-- | A monad transformer that is an instance of <a>MonadHaskey</a>.
--   
--   The <tt>root</tt> is the data type holding the roots of the database
--   trees.
data HaskeyT root m a

-- | Run Haskey transactions, backed by a file store.
runHaskeyT :: (Root root, MonadMask m, MonadIO m) => HaskeyT root m a -> ConcurrentDb root -> FileStoreConfig -> m a

-- | Monad in which on-disk storage operations can take place.
--   
--   Two important instances are <a>StoreM</a> making it a storage
--   back-end, and <a>ConcurrentMetaStoreM</a> making it a storage back-end
--   compatible with the concurrent page allocator.
data FileStoreT fp (m :: * -> *) a

-- | File store configuration.
--   
--   The default configuration can be obtained by using
--   <a>defFileStoreConfig</a>
--   
--   A configuration with a specific page size can be obtained by using
--   <a>fileStoreConfigWithPageSize</a>.
data FileStoreConfig

-- | Run the storage operations in the <a>FileStoreT</a> monad, given a
--   collection of open files.
runFileStoreT :: Monad m => FileStoreT FilePath m a -> FileStoreConfig -> m a

-- | The default configuration
--   
--   This is an unwrapped <a>fileStoreConfigWithPageSize</a> with a page
--   size of 4096 bytes.
defFileStoreConfig :: FileStoreConfig

-- | An active concurrent database.
--   
--   This can be shared amongst threads.
data ConcurrentDb root

-- | Construct a set of <a>ConcurrentHandles</a> from a root directory.
concurrentHandles :: FilePath -> ConcurrentHandles

-- | Open the an existing database, with the given handles.
openConcurrentDb :: (Root root, MonadIO m, MonadMask m, ConcurrentMetaStoreM m) => ConcurrentHandles -> m Maybe ConcurrentDb root

-- | Open a new concurrent database, with the given handles.
createConcurrentDb :: (Root root, MonadIO m, MonadMask m, ConcurrentMetaStoreM m) => ConcurrentHandles -> root -> m ConcurrentDb root
instance Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (Control.Monad.Haskey.HaskeyT root m)
instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Control.Monad.Haskey.HaskeyT root m)
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Control.Monad.Haskey.HaskeyT root m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Haskey.HaskeyT root m)
instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Haskey.HaskeyT root m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (Control.Monad.Haskey.HaskeyT root m)
instance GHC.Base.Functor m => GHC.Base.Functor (Control.Monad.Haskey.HaskeyT root m)
instance Control.Monad.Base.MonadBase GHC.Types.IO m => Control.Monad.Base.MonadBase GHC.Types.IO (Control.Monad.Haskey.HaskeyT root m)
instance (Database.Haskey.Alloc.Concurrent.Internal.Meta.Root root, GHC.Base.Applicative m, Control.Monad.Catch.MonadMask m, Control.Monad.IO.Class.MonadIO m) => Control.Monad.Haskey.MonadHaskey root (Control.Monad.Haskey.HaskeyT root m)
instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Haskey.HaskeyT root)
instance Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Haskey.HaskeyT root)
instance Control.Monad.Trans.Control.MonadBaseControl GHC.Types.IO m => Control.Monad.Trans.Control.MonadBaseControl GHC.Types.IO (Control.Monad.Haskey.HaskeyT root m)
instance Control.Monad.Reader.Class.MonadReader r m => Control.Monad.Reader.Class.MonadReader r (Control.Monad.Haskey.HaskeyT root m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Monad.Haskey.HaskeyT root m)
instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Haskey.HaskeyT root m)
instance Control.Monad.RWS.Class.MonadRWS r w s m => Control.Monad.RWS.Class.MonadRWS r w s (Control.Monad.Haskey.HaskeyT root m)
instance Control.Monad.Haskey.MonadHaskey root m => Control.Monad.Haskey.MonadHaskey root (Control.Monad.Trans.Reader.ReaderT r m)
instance Control.Monad.Haskey.MonadHaskey root m => Control.Monad.Haskey.MonadHaskey root (Control.Monad.Trans.State.Lazy.StateT s m)
instance Control.Monad.Haskey.MonadHaskey root m => Control.Monad.Haskey.MonadHaskey root (Control.Monad.Trans.State.Strict.StateT s m)
instance (GHC.Base.Monoid w, Control.Monad.Haskey.MonadHaskey root m) => Control.Monad.Haskey.MonadHaskey root (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (GHC.Base.Monoid w, Control.Monad.Haskey.MonadHaskey root m) => Control.Monad.Haskey.MonadHaskey root (Control.Monad.Trans.Writer.Strict.WriterT w m)
instance (GHC.Base.Monoid w, Control.Monad.Haskey.MonadHaskey root m) => Control.Monad.Haskey.MonadHaskey root (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance (GHC.Base.Monoid w, Control.Monad.Haskey.MonadHaskey root m) => Control.Monad.Haskey.MonadHaskey root (Control.Monad.Trans.RWS.Strict.RWST r w s m)
