Fast JSON parsing powered by Chad Austin's sajson library https://github.com/kccqzy/haskell-sajson#readme
|Latest on Hackage:||0.1.0.0|
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 stackage.org to host generated Haddocks.
This is a Haskell package that is a thin wrapper over the wonderful
sajson library written by Chad Austin.
It provides a high performance JSON parser written in C++11. After parsing, a
Data.Aeson.Value is constructed.
Who This Is For
This library is specifically designed for Haskell users who find the performance
of the pure-Haskell
Data.Aeson parser inadequate. This library focuses on
performance, not portability or absolute correctness. You should only use this
library if all of the following is true:
You are using a system that is 64-bit. This library assumes
sizeof(size_t) == 8. If this is not the case, the behavior is undefined.
You are using a system where the alignment of
doubleis no stricter than that of
size_t. Internally, the library casts a pointer to
size_tinto a pointer to
doubleand expects this to be meaningful.
You do not expect to parse floating point numbers beyond the range of
You do not expect to parse integers that are longer than 53 bits.
You do not expect parsing a JSON number will produce a Haskell
Scientificvalue that exactly represents the mathematical value of the JSON number, or even the closest approximation in IEEE-754
For example if you parse numbers that would be denormal numbers in IEEE-754 double-precision numbers, you will very likely get back zero instead.
As another example, if you parse
0.3, which cannot be represented exactly in IEEE-754
double, you will get back 0.30000000000000004, instead of the closest number in IEEE-754
doublewhich is 0.29999999999999999.
You wish to sacrifice memory consumption for speed. The intermediate memory needed is 9 times the number of bytes of the input
ByteStringplus constant. This excludes the memory needed by the parsed
Valueor the memory of the input
You are parsing JSON that is known to be valid. As a library written in C++, it is inherently unsafe. Despite the use of address sanitizer and AFL which have caught memory usage bugs, it is difficult to guarantee that creatively crafted input will not crash or cause arbitrary code execution. It is recommend that you use this library only for parsing known good JSON.
If you satisfy all of the above, then this library could work for you. Again, please benchmark and show that JSON parsing is indeed a bottleneck before using this library.
Ideas and Future Plan
Values when the you eventually want another Haskell type. Currently the
FromJSONinstance needs a
Value, but perhaps we can devise another method to avoid the generation of these intermediate
Provide a benchmark so that we can quantitatively argue this library parses JSON faster than
Provide an alternative for parsing floating point numbers that better preserves the value.
More complete tests, including QuickCheck-based tests.