The storable-record package

[Tags:bsd3, library]

With this package definition you can build a Storable instance of a record type from Storable instances of its elements. This is as simple as:

 import Foreign.Storable.Record as Store
 import Foreign.Storable (Storable (..), )

 import Control.Applicative (liftA2, )

 data Stereo a = Stereo (left, right :: a)
 -- parentheses must be curly braces, but Haddock does not like them

 store :: Storable a => Store.Dictionary (Stereo a)
 store = $
    liftA2 Stereo
       (Store.element left)
       (Store.element right)

 instance (Storable a) => Storable (Stereo a) where
    sizeOf = Store.sizeOf store
    alignment = Store.alignment store
    peek = Store.peek store
    poke = Store.poke store

I cannot promise that the generated memory layout is compatible with that of a corresponding C struct. However, the module generates the smallest layout that is possible with respect to the alignment of the record elements. Thus this package might provide a Haskell98 alternative to HSC without a preprocessor. If you encounter, that a record does not have a compatible layout, we should fix that. But also without C compatibility this package is useful e.g. in connection with StorableVector.

The Stereo constructor is exclusively used for constructing the peek function, where as the accessors in the element calls are used for assembling the poke function. It is required that the order of arguments of Stereo matches the record accessors in the element calls. If you want that the stored data correctly and fully represents your Haskell data, it must hold:

   Stereo (left x) (right x) = x   .

Unfortunately this cannot be checked automatically. However, mismatching types that are caused by swapped arguments are detected by the type system. Our system performs for you: Size and alignment computation, poking and peeking. Thus several inconsistency bugs can be prevented using this package, like size mismatches space required by poke actions. There is no more restriction, thus smart constructors and accessors and nested records work, too. For nested records however, I recommend individual Storable instances for the sub-records.

You see it would simplify class instantiation if we could tell the class dictionary at once instead of defining each method separately.

For examples see packages sox and synthesizer.


Versions 0.0.1, 0.0.2,,,,,, 0.0.3,
Dependencies base (>=1.0 && <2 || >=3), special-functors (==1.0.*), transformers (>=0.0.1 && <0.2), utility-ht (>=0.0.1 && <0.1) [details]
License BSD3
Author Henning Thielemann <>
Maintainer Henning Thielemann <>
Category Data, Foreign
Home page
Source repository head: darcs get
this: darcs get --tag 0.0.1
Uploaded Tue May 26 11:46:15 UTC 2009 by HenningThielemann
Distributions LTSHaskell:, NixOS:, Stackage:, Tumbleweed:
Downloads 4705 total (45 in the last 30 days)
0 []
Status Docs uploaded by user
Build status unknown [no reports yet]




splitbaseChoose the new smaller, split-up base package.EnabledAutomatic

Use -f <flag> to enable a flag, or -f -<flag> to disable that flag. More info


Maintainer's Corner

For package maintainers and hackage trustees