[Haskell] ANNOUNCE: Data.TCache 0.5.5

[Alberto G. Corona]

The main addition of this versión is the capablity to safely
handle transact, and serialize to permanent storage many datatypes
simultaneously in the same piece of code and incrementally.

Just register each new datatype (with registerType :: <Type>). So it is not
necessary to glue all types in advance in a single algebraic datatype. I
suppose taht "enhanced composablility" applies to this feature.

http://hackage.haskell.org/cgi-bin/hackage-scripts/package/TCache

        In this release:
           Added a Data.TCache.Dynamic.  (SEE dynamicsample.hs)
             - Can handle, transact, and serialize to disk many datatypes
simultaneously and incrementally
             - Dynamic uses the same interface than TCache and add
*DResource(s) calls for handling many
               datatypes simultaneously
             - Safe dynamic data handling trough a lighter, indexable and
serializable version of Data.Dynamic
             - Added KEY object for retrieving any object of any type.


        Data.Tcache is a transactional cache with configurable persistence.
It tries to simulate Hibernate
        for Java or Rails for Ruby. The main difference is that transactions
are done in memory trough STM.
        There are transactional cache implementations for some J2EE servers
like JBOSS.

        TCache uses STM. It can  atomically apply a function to a list of
cached objects. The resulting
        objects go back to the cache (withResources). It also can retrieve
these objects (getResources).
        Persistence can be syncronous (syncCache)  or asyncronous, wtih
configurable time between cache
        writes and configurable cache clearance strategy. the size of the
cache can be configured too .
        All of this can be done trough clearSyncCacheProc. Even the TVar
variables can be accessed
        directly (getTVar) to acceess all the semantic of atomic blocks
while maintaining the persistence of the
        TVar updates.

        Persistence can be defined for each object: Each object must have a
defined key, a default filename
        path (if applicable). Persistence is pre-defined in files, but the
readResource writeResource and
        delResource methods can be redefined to persist in databases or
whatever.

        There are  Samples in the package that explain the main features.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://www.haskell.org/pipermail/haskell/attachments/20090109/30f88266/attachment.htm