acid-state-0.11.4: Add ACID guarantees to any serializable Haskell data structure.

Portability | non-portable (uses GHC extensions)
Maintainer | lemmih@gmail.com
Safe Haskell | None

Data.Acid.Memory.Pure

Description

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

Synopsis

- class SafeCopy st => IsAcidic st where
  - acidEvents :: [Event st]
- data AcidState st
- data Event st where
  - 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
- type EventState ev = MethodState ev
- class Method ev => UpdateEvent ev
- class Method ev => QueryEvent ev
- data Update st a
- data Query st a
- openAcidState :: IsAcidic st => st -> AcidState st
- update :: UpdateEvent event => AcidState (EventState event) -> event -> (AcidState (EventState event), EventResult event)
- update_ :: UpdateEvent event => AcidState (EventState event) -> event -> AcidState (EventState event)
- query :: QueryEvent event => AcidState (EventState event) -> event -> EventResult event
- runQuery :: Query st a -> Update st a

# Documentation

class SafeCopy st => IsAcidic st where Source

Methods

acidEvents Source

Arguments

:: [Event st] | List of events capable of updating or querying the state.

data AcidState st Source

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 Source

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 evSource

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

type EventState ev = MethodState evSource

class Method ev => UpdateEvent ev Source

All UpdateEvents are also Methods.

class Method ev => QueryEvent ev Source

All QueryEvents are also Methods.

data Update st a Source

Context monad for Update events.

Instances

MonadState st (Update st) |
Monad (Update st) |
Functor (Update st) |
Applicative (Update st) |

data Query st a Source

Context monad for Query events.

Instances

MonadReader st (Query st) |
Monad (Query st) |
Functor (Query st) |
Applicative (Query st) |

openAcidState Source

Arguments

:: IsAcidic st |
=> st | Initial state value.
-> AcidState st |

Create an AcidState given an initial value.

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

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.

update_ :: UpdateEvent event => AcidState (EventState event) -> event -> AcidState (EventState event)Source

Same as `update` but ignoring the event result.

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

Issue a Query event and wait for its result.

runQuery :: Query st a -> Update st aSource

Run a query in the Update Monad.