In favour of


A thread-safe (STM) persistency interface for finite map types.

Latest on Hackage:0.3.5

This package is not currently in any snapshots. If you're interested in using it, we recommend adding it to Stackage Nightly. Doing so will make builds more reliable, and allow to host generated Haddocks.

LGPL licensed by Peter Robinson 2009
Maintained by Peter Robinson

Changes in 0.3.*:

  • Added the TFiniteMap type to make type construction more convenient.

  • Added markAsDirty.

  • Fixed data corruption issues with Backend.Binary.

Changes in 0.2.*:

  • Improved error handling. Backend lookup-exceptions are now rethrown in the AdvSTM monad.

Changes in 0.1.*:

  • Added the binary serialization backend.

This library provides a thread-safe (STM) frontend for finite map types together with a backend interface for persistent storage. The TMap data type is thread-safe, since all access functions run inside an STM monad . Any type instantiating Data.Edison.Assoc.FiniteMapX (see EdisonAPI) can be used as a map type.

When a TMap is modified within an STM transaction, a corresponding backend IO-request is added using the onCommit hook (cf. stm-io-hooks package). To ensure consistency, the (Adv)STM monad runs these requests iff the transaction commits. Additional backends (e.g. HDBC) can be added by instantiating the class Backend.


Thread 1:

atomically $ do
  isMemb <- member 1 tmap
  when (not isMemb) $
    insert 1 "john doe" tmap

Thread 2:

atomically $ do
  v <- lookup 1 tmap
  -- ... do something with 'v'
  adjust (\_ -> "jd") 1 tmap

The function member will first check whether the key value 1 is in the map; if not, it sends a lookup-request to the persistent backend and then retries the transaction. Note that "sending a lookup-request" essentially means adding a call to the corresponding IO-function of the backend to the list of retry-IO actions. (This is done using the retryWith IO hook of the stm-io-package.)

If the value does not yet exist, function insert adds the key-value mapping to the TMap and sends an insert-request to the backend using the onCommit hook of the stm-io-package. Note that onCommit guarantees that the backend IO action is only executed iff the transaction commits. Any changes that were made to the TMap are invisible to other threads until the onCommit actions are run. Therefore, the threads will always observe a consistent state.

The module Data.TStorage provides a high level interface to TMap inspired by the TCache package ((C) Alberto Gomez Corona). It can store any type that has a key (i.e. is an instance of type class HasKey). See file Sample.hs for an example on how to use it.

Warning: This package is very experimental and the interface will probably change.

comments powered byDisqus