Data.Acid.Memory

AcidState container without a transaction log. Mostly used for testing.

Documentation

class SafeCopy st => IsAcidic st where

Methods

acidEvents

Arguments

:: [Event st]

List of events capable of updating or querying the state.

data AcidState st

State container offering full ACID (Atomicity, Consistency, Isolation and Durability) guarantees.

Atomicity

State changes are all-or-nothing. This is what you'd expect of any state variable in Haskell and AcidState doesn't change that.

Consistency

No event or set of events will break your data invariants.

Isolation

Transactions cannot interfere with each other even when issued in parallel.

Durability

Successful transaction are guaranteed to survive system failure (both hardware and software).

data Event st where

We distinguish between events that modify the state and those that do not.

UpdateEvents are executed in a MonadState context and have to be serialized to disk before they are considered durable.

QueryEvents are executed in a MonadReader context and obviously do not have to be serialized to disk.

Constructors

UpdateEvent :: UpdateEvent ev => (ev -> Update (EventState ev) (EventResult ev)) -> Event (EventState ev)

QueryEvent :: QueryEvent ev => (ev -> Query (EventState ev) (EventResult ev)) -> Event (EventState ev)

type EventResult ev = MethodResult ev

Events return the same thing as Methods. The exact type of EventResult depends on the event.

type EventState ev = MethodState ev

class Method ev => UpdateEvent ev

All UpdateEvents are also Methods.

class Method ev => QueryEvent ev

All QueryEvents are also Methods.

data Update st a

Context monad for Update events.

Instances

MonadState st (Update st)

Monad (Update st)

Functor (Update st)

Applicative (Update st)

data Query st a

Context monad for Query events.

Instances

MonadReader st (Query st)

Monad (Query st)

Functor (Query st)

Applicative (Query st)

openAcidState

Arguments

:: IsAcidic st

=> st

Initial state value.

-> IO (AcidState st)

Create an AcidState given an initial value.

closeAcidState :: AcidState st -> IO ()

Close an AcidState and associated logs. Any subsequent usage of the AcidState will throw an exception.

createCheckpoint :: SafeCopy st => AcidState st -> IO ()

This is a nop with the memory backend.

createCheckpointAndClose :: SafeCopy st => AcidState st -> IO ()

This is an alias for closeAcidState when using the memory backend.

update :: UpdateEvent event => AcidState (EventState event) -> event -> IO (EventResult event)

Issue an Update event and wait for its result. Once this call returns, you are guaranteed that the changes to the state are durable. Events may be issued in parallel.

It's a run-time error to issue events that aren't supported by the AcidState.

scheduleUpdate :: UpdateEvent event => AcidState (EventState event) -> event -> IO (MVar (EventResult event))

Issue an Update event and return immediately. The event is not durable before the MVar has been filled but the order of events is honored. The behavior in case of exceptions is exactly the same as for update.

If EventA is scheduled before EventB, EventA will be executed before EventB:

do scheduleUpdate acid EventA
   scheduleUpdate acid EventB

query :: QueryEvent event => AcidState (EventState event) -> event -> IO (EventResult event)

Issue a Query event and wait for its result. Events may be issued in parallel.

update' :: (UpdateEvent event, MonadIO m) => AcidState (EventState event) -> event -> m (EventResult event)

Same as update but lifted into any monad capable of doing IO.

query' :: (QueryEvent event, MonadIO m) => AcidState (EventState event) -> event -> m (EventResult event)

Same as query but lifted into any monad capable of doing IO.

runQuery :: Query st a -> Update st a

Run a query in the Update Monad.