store

Fast binary serialization

Version on this page:	0.5.0.1
LTS Haskell 20.23:	0.7.16
Stackage Nightly 2023-05-30:	0.7.16
Latest on Hackage:	0.7.16

See all snapshots store appears in

MIT licensed

Maintained by Michael Sloan

This version can be pinned in stack with:store-0.5.0.1@sha256:3a1cef93e5f660286da19f6ca6192c8782c2145a88913e5f9d6ac71ddbce55c4,6992

Module documentation for 0.5.0.1

Data
- Data.Store
System
- System.IO
  - System.IO.ByteBuffer

Depends on 42 packages(full list with versions):

Used by 2 packages in lts-12.26(full list with versions):

safe-money, stack

store

The ‘store’ package provides efficient binary serialization. There are a couple features that particularly distinguish it from most prior Haskell serialization libraries:

Its primary goal is speed. By default, direct machine representations are used for things like numeric values (Int, Double, Word32, etc) and buffers (Text, ByteString, Vector, etc). This means that much of serialization uses the equivalent of memcpy.

We have plans for supporting architecture independent serialization - see #36 and #31. This plan makes little endian the default, so that the most common endianness has no overhead.
Instead of implementing lazy serialization / deserialization involving multiple input / output buffers, peek and poke always work with a single buffer. This buffer is allocated by asking the value for its size before encoding. This simplifies the encoding logic, and allows for highly optimized tight loops.
store can optimize size computations by knowing when some types always use the same number of bytes. This allows us to compute the byte size of a Vector Int32 by just doing length v * 4.

It also features:

Optimized serialization instances for many types from base, vector, bytestring, text, containers, time, template-haskell, and more.
TH and GHC Generics based generation of Store instances for datatypes
TH generation of testcases.
Utilities for streaming encoding / decoding of Store encoded messages, via the store-streaming package.

Blog posts

Initial release announcement
Benchmarks of the prototype
New ‘weigh’ allocation benchmark package, created particularly to aid optimizing store.

Changes

ChangeLog

0.5.0.1

Updates to test-suite enabling store to build with newer dependencies.

0.5.0

Data.Store.Streaming moved to a separate package, store-streaming.

0.4.3.2

Buildable with GHC 8.2
Fix to haddock formatting of Data.Store.TH code example

0.4.3.1

Fixed compilation on GHC 7.8

0.4.3

Less aggressive inlining, resulting in faster compilation / simplifier not running out of ticks

0.4.2

Fixed testsuite

0.4.1

Breaking change in the encoding of Map / Set / IntMap / IntSet, to use ascending key order. Attempting to decode data written by prior versions of store (and vice versa) will almost always fail with a decent error message. If you’re unlucky enough to have a collision in the data with a random Word32 magic number, then the error may not be so clear, or in extremely rare cases, successfully decode, yielding incorrect results. See #97 and #101.
Performance improvement of the ‘Peek’ monad, by introducing more strictness. This required a change to the internal API.
API and behavior of ‘Data.Store.Version’ changed. Previously, it would check the version tag after decoding the contents. It now also stores a magic Word32 tag at the beginning, so that it fails more gracefully when decoding input that lacks encoded version info.

0.4.0

Deprecated in favor of 0.4.1

0.3.1

Fix to derivation of primitive vectors, only relevant when built with primitive-0.6.2.0 or later
Removes INLINE pragmas on the generic default methods. This dramatically improves compilation time on recent GHC versions. See #91.
Adds instance Contravariant Size

0.3

Uses store-core-0.3.*, which has support for alignment sensitive architectures.
Adds support for streaming decode from file descriptor, not supported on windows. As part of this addition, the API for “Data.Store.Streaming” has changed.

0.2.1.2

Fixes a bug that could could result in attempting to malloc a negative number of bytes when reading corrupted data.

0.2.1.1

Fixes a bug that could result in segfaults when reading corrupted data.

0.2.1.0

Release notes:

Adds experimental Data.Store.Version and deprecates Data.Store.TypeHash. The new functionality is similar to TypeHash, but there are much fewer false positives of hashes changing.

Other enhancements:

Now exports types related to generics

0.2.0.0

Release notes:

Core functionality split into store-core package

Breaking changes:

combineSize' renamed to combineSizeWith
Streaming support now prefixes each Message with a magic number, intended to detect mis-alignment of data frames. This is worth the overhead, because otherwise serialization errors could be more catastrophic - interpretting some bytes as a length tag and attempting to consume many bytes from the source.

Other enhancements:

weigh based allocations benchmark.
Addition of Array / UArray instances
Streaming support now has checks for over/undershooting buffer

Bug fixes:

0.1.0.0

First public release