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 =
    Store.run $
    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.


Properties

Versions0.0.1, 0.0.2, 0.0.2.1, 0.0.2.2, 0.0.2.3, 0.0.2.4, 0.0.2.5, 0.0.3
Dependenciesbase (>=1.0 && <2), special-functors (==1.0.*), transformers (>=0.0.1 && <0.2), utility-ht (>=0.0.1 && <0.1) or
base (>=3), transformers (>=0.0.1 && <0.2), utility-ht (>=0.0.1 && <0.1)
LicenseBSD3
AuthorHenning Thielemann <storable@henning-thielemann.de>
MaintainerHenning Thielemann <storable@henning-thielemann.de>
StabilityExperimental
CategoryData, Foreign
Home pagehttp://code.haskell.org/~thielema/storable-record/
Source repositoryhead: darcs get http://code.haskell.org/~thielema/storable-record/
this: darcs get http://code.haskell.org/~thielema/storable-record/ --tag 0.0.1
Upload dateTue May 26 11:46:15 UTC 2009
Uploaded byHenningThielemann
DistributionsNixOS:0.0.3
Downloads2053 total (157 in last 30 days)

Modules

[Index]

Flags

NameDescriptionDefault
splitbaseChoose the new smaller, split-up base package.Enabled

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

Downloads

Maintainers' corner

For package maintainers and hackage trustees