1For the latest version of this document, please see [https://github.com/bos/aeson/blob/master/changelog.md](https://github.com/bos/aeson/blob/master/changelog.md).
5* `FromJSON` instance of `Ratio a` now parses numbers in addtion to
6 standard `{numerator=..., denumerator=...}` encoding.
10* Provide a clearer error message when a required tagKey for a constructor is missing, thanks to Guru Devanla.
11 The error message now looks like this: `Error in $: parsing Types.SomeType failed, expected Object with key "tag" containing one of ["nullary","unary","product","record","list"], key "tag" not found`
13* Add `formatPath` and `formatRelativePath` functions to turn a `JSONPath` into a `String`, thanks to Robbie McMichael
18* Expose `(<?>)`, `JSONPath` and `JSONPathElement(..)` from `Data.Aeson.Types`. Previously only available through internal modules. Thanks to Luke Clifton.
20* Support for base-compat 0.11, thanks to Ryan Scott.
22* Travis build for GHC 8.8, thanks to Oleg Grenrus.
28* Adds a parameterized parser `jsonWith` that can be used to choose how to handle duplicate keys in objects, thanks to Xia Li-Yao.
30* Add generic implementations of `FromJSONKey` and `ToJSONKey`, thanks to Xia Li-Yao. Example:
37opts = defaultJSONKeyOptions { keyModifier = toLower }
39instance ToJSONKey Foo where
40 toJSONKey = genericToJSONKey opts
42instance FromJSONKey Foo where
43 fromJSONKey = genericFromJSONKey opts
47* aeson now uses `time-compat` instead of `time-locale-compat`, thanks to Oleg Grenrus.
48* Prepare for `MonadFail` breakages in GHC 8.8, thanks to Oleg Grenrus.
49* Require `bytestring >= 0.10.8.1` for newer GHCs to avoid build failures, thanks to Oleg Grenrus.
50* Support `primitive 0.7.*`, thanks to Adam Bergmark.
51* Allow `semigroups 0.19.*` and `hashable 1.3.*`, thanks to Oleg Grenrus.
52* Fix a typo in the error message when parsing `NonEmpty`, thanks to Colin Woodbury.
53* Document surprising behavior when using `omitNothingFields` with type variables, thanks to Xia Li-Yao.
56* Code cleanup by Oleg Grenrus
57* Fix dependencies of the benchmarks on older GHC's, thanks to Xia Li-Yao.
60* Improve error messages for FromJSON in existing instances and GHC Generic implementation. Thanks to Xia Li-Yao & Igor Pashev.
61* Tweak error-reporting combinators and their documentation. Thanks to Xia Li-Yao.
62 * `typeMismatch` is now about comparing JSON types (i.e., the expected and actual names of the Value constructor).
63 * `withObject` and other `with*` combinators now also mention the JSON types they expect
64 * New `unexpected` and `prependFailure` combinators.
65* Add `Contravariant` `ToJSONKeyFunction` instance. Thanks to Oleg Grenrus.
66* Add `KeyValue` instance for `Object`. Thanks to Robert Hensing.
67* Improve performance when parsing certain large numbers, thanks to Oleg Grenrus.
68* Add `Data.Aeson.QQ.Simple` - A limited version of aeson-qq. Thanks to Oleg Grenrus.
69* Exposes internal helper functions like `<?>`, `JSONPath`, and `parseIndexedJSON` from `Data.Aeson` module. Thanks to Abid Uzair.
70* Better error messages when there are syntax errors parsing objects and arrays. Thanks to Fintan Halpenny.
71* Support building with `th-abstraction-0.3.0.0` or later. Thanks to Ryan Scott.
75* Add `Data.Aeson.QQ.Simple` which is a simpler version of the `aeson-qq` package, it does not support interpolation, thanks to Oleg Grenrus.
76* Add `Contravariant ToJSONKeyFunction` instance, thanks to Oleg Grenrus.
77* Add `KeyValue Object` instance, thanks to Robert Hensing
78* Improved performance when parsing large numbers, thanks to Oleg Grenrus.
82* Optimizations of generics, thanks to Rémy Oudompheng, here are some numbers for GHC 8.4:
83 * Compilation time: G/BigProduct.hs is 25% faster, G/BigRecord.hs is 2x faster.
84 * Runtime performance: BigRecord/toJSON/generic and BigProduct/encode/generic are more than 2x faster.
85* Added To/FromJSON instances for `Void` and Generics's `V1`, thanks to Will Yager
86* Added To/FromJSON instances for `primitive`'s `Array`, `SmallArray`, `PrimArray` and `UnliftedArray`, thanks to Andrew Thad.
87* Fixes handling of `UTCTime` wrt. leap seconds , thanks to Adam Schønemann
88* Warning and documentation fixes thanks to tom-bop, Gabor Greif, Ian Jeffries, and Mateusz Curyło.
92This release introduces bounds on the size of `Scientific` numbers when they are converted to other arbitrary precision types that do not represent them efficiently in memory.
94This means that trying to decode a number such as `1e1000000000` into an `Integer` will now fail instead of using a lot of memory. If you need to represent large numbers you can add a newtype (preferably over `Scientific`) and providing a parser using `withScientific`.
96The following instances are affected by this:
98* `FromJSONKey Natural`
100* `FromJSONKey Integer`
101* `FromJSON NominalDiffTime`
103For the same reasons the following instances & functions have been removed:
104* Remove `FromJSON Data.Attoparsec.Number` instance. Note that `Data.Attoparsec.Number` is deprecated.
105* Remove deprecated `withNumber`, use `withScientific` instead.
107Finally, encoding integral values with large exponents now uses scientific notation, this saves space for large numbers.
111* Catch 0 denominators when parsing Ratio
115* Fix bug in generically derived `FromJSON` instances that are using `unwrapUnaryRecords`, thanks to Xia Li-yao
116* Allow base-compat 0.10.*, thanks to Oleg Grenrus
121* `GKeyValue` has been renamed to `KeyValuePair`, thanks to Xia Li-yao
122* Removed unused `FromJSON` constraint in `withEmbeddedJson`, thanks to Tristan Seligmann
125* Optimizations of TH toEncoding, thanks to Xia Li-yao
126* Optimizations of hex decoding when using the default/pure unescape implementation, thanks to Xia Li-yao
127* Improved error message on `Day` parse failures, thanks to Gershom Bazerman
128* Add `encodeFile` as well as `decodeFile*` variants, thanks to Markus Hauck
129* Documentation fixes, thanks to Lennart Spitzner
130* CPP cleanup, thanks to Ryan Scott
134* Add `Ord` instance for `JSONPathElement`, thanks to Simon Hengel.
139* Added `withEmbeddedJSON` to help parse JSON embedded inside a JSON string, thanks to Jesse Kempf.
140* Memory usage improvements to the default (pure) parser, thanks to Jonathan Paugh. Also thanks to Neil Mitchell & Oleg Grenrus for contributing a benchmark.
141* `omitNothingFields` now works for the `Option` newtype, thanks to Xia Li-yao.
142* Some documentation fixes, thanks to Jonathan Paug & Philippe Crama.
146* Add `FromJSON` and `ToJSON` instances for
147 * `DiffTime`, thanks to Víctor López Juan.
148 * `CTime`, thanks to Daniel Díaz.
149* Fix handling of fractions when parsing Natural, thanks to Yuriy Syrovetskiy.
150* Change text in error messages for Integral types to make them follow the common pattern, thanks to Yuriy Syrovetskiy.
151* Add missing `INCOHERENT` pragma for `RecordToPair`, thanks to Xia Li-yao.
152* Everything related to `Options` is now exported from `Data.Aeson`, thanks to Xia Li-yao.
153* Optimizations to not escape text in clear cases, thanks to Oleg Grenrus.
154* Some documentation fixes, thanks to Phil de Joux & Xia Li-yao.
158* Add `parserThrowError` and `parserCatchError` combinators, thanks to Oleg Grenrus.
160* Add `Generic` instance for `Value`, thanks to Xia Li-yao.
162* Fix a mistake in the 1.2.0.0 changelog, the `cffi` flag is disabled by default! Thanks to dbaynard.
166* `tagSingleConstructors`, an option to encode single-constructor types as tagged sums was added to `Options`. It is disabled by default for backward compatibility.
168* The `cffi` flag is now turned off (`False`) by default, this means C FFI code is no longer used by default. You can flip the flag to get C implementation.
170* The `Options` constructor is no longer exposed to prevent new options from being breaking changes, use `defaultOptions` instead.
172* The contents of `GToJSON` and `GToEncoding` are no longer exposed.
174* Some INLINE pragmas were removed to avoid GHC running out of simplifier ticks.
178* Fix an accidental change in the format of `deriveJSON`. Thanks to Xia Li-yao!
180* Documentation improvements regarding `ToJSON`, `FromJSON`, and `SumEncoding`. Thanks to Xia Li-yao and Lennart Spitzner!
184* Added a pure implementation of the C FFI code, the C FFI code. If you wish to use the pure haskell version set the `cffi` flag to `False`. This should make aeson compile when C isn't available, such as for GHCJS. Thanks to James Parker & Marcin Tolysz!
186* Using the `fast` flag can no longer cause a test case to fail. As far as we know this didn't affect any users of the library itself. Thanks to Xia Li-yao!
190* Added instances for `UUID`.
192* The operators for parsing fields now have named aliases:
193 - `.:` => `parseField`
194 - `.:?` => `parseFieldMaybe`
195 - `.:!` => `parseFieldMaybe'`
196 - These functions now also have variants with explicit parser functions: `explicitParseField`, `explicitParseFieldMaybe`, "explicitParseFieldMaybe'`
197Thanks to Oleg Grenrus.
199* `ToJSONKey (Identity a)` and `FromJSONKey (Identity a)` no longer require the unnecessary `FromJSON a` constraint. Thanks to Oleg Grenrus.
201* Added `Data.Aeson.Encoding.pair'` which is a more general version of `Data.Aeson.Encoding.pair`. Thanks to Andrew Martin.
203* `Day`s BCE are properly encoded and `+` is now a valid prefix for `Day`s CE. Thanks to Matt Parsons.
205* Some commonly used ToJSON instances are now specialized in order to improve compile time. Thanks to Bartosz Nitka.
208[JSONTestSuite](https://github.com/nst/JSONTestSuite) cleanups, all
209motivated by tighter RFC 7159 compliance:
211* The parser now rejects numbers for which
212 [the integer portion contains a leading zero](https://github.com/bos/aeson/commit/3fb7c155f2255482b1b9566ec5c1eaf9895d630e).
213* The parser now rejects numbers for which
214 [a decimal point is not followed by at least one digit](https://github.com/bos/aeson/commit/ecfca35a45286dbe2bbaf5f62354be393bc59b66),
215* The parser now rejects documents that contain [whitespace outside the
216 set {space, newline, carriage return, tab}](https://github.com/bos/aeson/commit/8ef622c2ad8d4a109884e17c2792238a2a320e44).
218Over 90% of JSONTestSuite tests currently pass. The remainder can be
219categorised as follows:
221* The string parser is strict with Unicode compliance where the RFC
222 leaves room for implementation-defined behaviour (tests prefixed
223 with "`i_string_`". (This is necessary because the `text` library
224 cannot accommodate invalid Unicode.)
226* The parser does not (and will not) support UTF-16, UTF-32, or byte
228* The parser accepts unescaped control characters, even though the RFC
229 states that control characters must be escaped. (This may change at
230 some point, but doesn't seem important.)
234* Fixes a regression where a bunch of valid characters caused an
235 "Invalid UTF8-Stream" error when decoding. Thanks to Vladimir
236 Shabanov who investigated and fixed this.
240* Fixes a regression where it was no longer possible to derive
241 instances for types such as `data T a = T { f1 :: a, f2 :: Maybe a
244Thanks to Sean Leather for fixing this, and to Ryan Scott for helping out.
248* Decoding performance has been significantly improved (see
249 https://github.com/bos/aeson/pull/452). Thanks to @winterland1989.
251* Add `ToJSON`/`FromJSON` instances for newtypes from
252 `Data.Semigroup`: `Min`, `Max`, `First`, `Last`, `WrappedMonoid`,
253 `Option`. Thanks to Lennart Spitzner.
255* Make the documentation for `.:!` more accurate. Thanks to Ian Jeffries.
261* Introduced new `FromJSONKey` and `ToJSONKey` type classes that are
262 used to encode maps without going through HashMap. This also allows arbitrary
263 serialization of keys where a string-like key will encode into an object and
264 other keys will encode into an array of key-value tuples.
266* Added higher rank classes: `ToJSON1`, `ToJSON2`, `FromJSON1`, and
269* Added `Data.Aeson.Encoding` with functions to safely write `ToJSON`
270 instances using `toEncoding`.
274* A Cabal `fast` flag was added to disable building with optimizations. This drastically speeds up compiling both aeson ***and*** libraries using aeson so it is recommended to enable it during development. With cabal-install you can `cabal install aeson -ffast` and with stack you can add a flag section to your stack.yaml:
281* Added list specific members to `ToJSON` and `FromJSON` classes. In
282 the same way `Read` and `Show` handle lists specifically. This
283 removes need for overlapping instances to handle `String`.
285* Added a new `sumEncoding` option `UntaggedValue` which prevents
286 objects from being tagged with the constructor name.
288* JSONPaths are now tracked in instances derived with template-haskell
291* Get rid of redundancy of JSONPath error messages in nested records.
293 `eitherDecode "{\"x\":{\"a\": [1,2,true]}}" :: Either String Y`
295 `Error in $.x.a[2]: failed to parse field" x: failed to parse field a: expected Int, encountered Boolean`
296 and now yields `Error in $.x.a[2]: expected Int, encountered Boolean"`.
298 Some users might prefer to insert `modifyFailure` themselves to
299 customize error messages, which previously prevented the use of
302* Backwards compatibility with `bytestring-0.9` using the
303 `bytestring-builder` compatibility package.
305* Export `decodeWith`, `decodeStrictWith`, `eitherDecodeWith`, and
306 `eitherDecodeStrictWith` from `Data.Aeson.Parser`. This allows
307 decoding using explicit parsers instead of using `FromJSON`
310* Un-orphan internal instances to render them in haddocks.
314* Integral `FromJSON` instances now only accept integral
315 values. E.g. parsing `3.14` to `Int` fails instead of succeeding
318* Over/underflows are now caught for bounded numeric types.
320* Remove the `contents` field encoding with `allNullaryToStringTag = False`,
321 giving us `{ "tag" : "c1" }` instead of `{ "tag" : "c1", contents : [] }`.
322 The contents field is optional when parsing so this is only a breaking
323 change for ToJSON instances.
325* Fix a bug where `genericToEncoding` with `unwrapUnaryRecords = True`
326 would produce an invalid encoding: `"unwrap\":""`.
328* `ToJSON` instances using `genericToEncoding` and `omitNothingFields`
329 no longer produce invalid JSON.
331* Added instances for `DList`, `Compose`, `Product`, `Sum`.
335* Enable `PolyKinds` to generalize `Proxy`, `Tagged`, and `Const` instances.
336* Add `unsafeToEncoding` in `Data.Aeson.Types`, use with care!
340* Fix build with `base >= 4.8` and `unordered-containers < 0.2.6`.
344* Fix build on TH-less GHCs
348* Fix build with `base < 4.8` and `unordered-containers < 0.2.6`.
349* Add missing field in docs for `defaultOptions`.
353* Fixes a bug where the hashes of equal values could differ.
357The only changes are added instances.
360* `ToJSON a => ToJSON (NonEmpty a)`
361* `FromJSON a => FromJSON (NonEmpty a)`
363* `FromJSON (Proxy a)`
364* `ToJSON b => ToJSON (Tagged a b)`
365* `FromJSON b => FromJSON (Tagged a b)`
366* `ToJSON a => ToJSON (Const a b)`
367* `FromJSON a => FromJSON (Const a b)`
369These are now available for older GHCs:
375This release should be close to backwards compatible with aeson 0.9.
377If you are upgrading from aeson 0.10 it might be easier to go back in
378history to the point you were still using 0.9.
382* Revert `.:?` to behave like it did in 0.9. If you want the 0.10
383 behavior use `.:!` instead.
385* Revert JSON format of `Either` to 0.9, `Left` and `Right` are now
386 serialized with an initial uppercase letter. If you want the names
387 in lowercase you can add a newtype with an instance.
389* All `ToJSON` and `FromJSON` instances except for `[a]` are no longer
390 `OVERLAPPABLE`. Mark your instance as `OVERLAPPING` if it overlaps
391 any of the other aeson instances.
393* All `ToJSON` and `FromJSON` instances except for `[Char]` are no
394 longer incoherent, this means you may need to replace your
395 incoherent instances with a newtyped instance.
399* Introduce `.:!` that behaves like `.:?` did in 0.10.
401* Allow `HH:MM` format for `ZonedTime` and `UTCTime`.
402 This is one of the formats allowed by
403 [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Times).
405* Added `ToJSON` and `FromJSON` instances for the
406 `Version`, `Ordering`, and `Natural` types.
410* JSONPath identifiers are now escaped if they contain invalid characters.
412* Fixed JSONPath messages for Seq to include indices.
414* Fixed JSONPath messages for Either to include `left`/`right`.
416* Fix missing quotes surrounding time encodings.
418* Fix #293: Type error in TH when using `omitNothingFields = True`.
422* Various updates to support GHC 8.
427## Performance improvements
429* Direct encoding via the new `toEncoding` method is over 2x faster
430 than `toJSON`. (You must write or code-gen a `toEncoding`
431 implementation to unlock this speedup. See below for details.)
433* Improved string decoding gives a 12% speed win in parsing
434 string-heavy JSON payloads (very common).
436* Encoding and decoding of time-related types are 10x faster (!!) as a
437 result of bypassing `Data.Time.Format` and the arbitrary-precision
440* When using `toEncoding`, `[Char]` can be encoded without a conversion to
441 `Text`. This is fast and efficient.
443* Parsing into an `Object` is now 5% faster and more
444 allocation-efficient.
446## SUBTLE API CHANGES, READ CAREFULLY
448With the exception of long-deprecated code, the API changes below
449**should be upwards compatible** from older versions of `aeson`. If you run
450into upgrade problems, please file an issue with details.
452* The `ToJSON` class has a new method, `toEncoding`, that allows
453 direct encoding from a Haskell value to a lazy bytestring without
454 construction of an intermediate `Value`.
456 The performance benefits of direct encoding are significant: more
457 than 2x faster than before, with less than 1/3 the memory usage.
459 To preserve API compatibility across upgrades from older versions of
460 this library, the default implementation of `toEncoding` uses
461 `toJSON`. You will *not* see any performance improvement unless you
462 write an implementation of `toEncoding`, which can be very simple:
465 instance ToJSON Coord where
466 toEncoding = genericToEncoding defaultOptions
469 (Behind the scenes, the `encode` function uses `toEncoding` now, so
470 if you implement `toEncoding` for your types, you should see a
471 speedup immediately.)
473 If you use Template Haskell or GHC Generics to auto-generate your
474 `ToJSON` instances, you'll benefit from fast toEncoding
475 implementations for free!
477* When converting from a `Value` to a target Haskell type, `FromJSON`
478 instances now provide much better error messages, including a
479 complete JSON path from the root of the object to the offending
480 element. This greatly eases debugging.
482* It is now possible to use Template Haskell to generate `FromJSON`
483 and `ToJSON` instances for types in data families.
485* If you use Template Haskell or generics, and used to use the
486 `camelTo` function to rename fields, the new `camelTo2` function is
487 smarter. For example, `camelTo` will rename `CamelAPICase` to
488 `camelapi_case` (ugh!), while `camelTo2` will map it to
489 `camel_api_case` (yay!).
491* New `ToJSON` and `FromJSON` instances for the following time-related
492 types: `Day`, `LocalTime`.
494* `FromJSON` `UTCTime` parser accepts the same values as for `ZonedTime`,
495 but converts any time zone offset into a UTC time.
497* The `Result` type is now an instance of `Foldable` and `Traversable`.
499* The `Data.Aeson.Generic` module has been removed. It was deprecated in
502* GHC 7.2 and older are no longer supported.
504* The instance of `Monad` for the `Result` type lacked an implementation
505 of `fail` (oops). This has been corrected.
507* Semantics of `(.:?)` operator are changed. It's doesn't anymore accept
508 present `Null` value.
510* Added `(Foldable t, ToJSON a) => ToJSON (t a)` overlappable instance.
511 You might see `No instance for (Foldable YourPolymorphicType) arising from a
512 use of ‘.=’` -errors due this change.
516* A stray export of `encodeToBuilder` got away!
520* The `json` and `json'` parsers are now synonyms for `value` and
521 `value'`, in conformance with the looser semantics of RFC 7159.
523* Renamed `encodeToByteStringBuilder` to the more compact
528* The dependency on the `unordered-containers` package was too lax,
529 and has been corrected.
533* Encoding a `Scientific` value with a huge exponent is now handled
534 efficiently. (This would previously allocate a huge
535 arbitrary-precision integer, potentially leading to a denial of
538* Handling of strings that contain backslash escape sequences is
539 greatly improved. For a pathological string containing almost a
540 megabyte of consecutive backslashes, the new implementation is 27x
541 faster and uses 42x less memory.
543* The `ToJSON` instance for `UTCTime` is rendered with higher
544 (picosecond) resolution.
546* The `value` parser now correctly handles leading whitespace.
548* New instances of `ToJSON` and `FromJSON` for `Data.Sequence` and
549 `Data.Functor.Identity`. The `Value` type now has a `Read` instance.
551* `ZonedTime` parser ordering now favours the standard `JSON` format,
552 increasing efficiency in the common case.
554* Encoding to a `Text.Builder` now escapes `'<'` and `'>'` characters,
559* Fix `ToJSON` instance for 15-tuples (see #223).
567* Add `ToJSON` and `FromJSON` instances for tuples of up to 15
572* Major compiler and library compatibility changes: we have dropped
573 support for GHC older than 7.4, `text` older than 1.1, and
574 `bytestring` older than 0.10.4.0. Supporting the older versions had
575 become increasingly difficult, to the point where it was no longer
580* The performance of encoding to and decoding of bytestrings have both
581 improved by up to 2x, while also using less memory.
583* New dependency: the `scientific` package lets us parse floating point
584 numbers more quickly and accurately.
586* `eitherDecode`, `decodeStrictWith`: fixed bugs.
588* Added `FromJSON` and `ToJSON` instances for `Tree` and `Scientific`.
590* Fixed the `ToJSON` instances for `UTCTime` and `ZonedTime`.
594* Much improved documentation.
596* Angle brackets are now escaped in JSON strings, to help avoid XSS
599* Fixed up handling of nullary constructors when using generic
602* Added `ToJSON`/`FromJSON` instances for:
605 * ISO-8601 dates: `UTCTime`, `ZonedTime`, and `TimeZone`
607* Added accessor functions for inspecting `Value`s.
609* Added `eitherDecode` function that returns an error message if
614* This release introduces a slightly obscure, but
615 backwards-incompatible, change.
617 In the generic APIs of versions 0.4 and 0.5, fields whose names
618 began with a `"_"` character would have this character removed. This
619 no longer occurs, as it was both buggy and surprising
620 (https://github.com/bos/aeson/issues/53).
622* Fixed a bug in generic decoding of nullary constructors
623 (https://github.com/bos/aeson/issues/62).
627* When used with the UTF-8 encoding performance improvements
628 introduced in version 0.11.1.12 of the `text` package, this release
629 improves `aeson`'s JSON encoding performance by 33% relative to
632 As part of achieving this improvement, an API change was necessary.
633 The `fromValue` function in the `Data.Aeson.Encode` module now uses
634 the `text` package's `Builder` type instead of the `blaze-builder`
635 package's `Builder` type.
639* The new `decode` function complements the longstanding `encode`
640 function, and makes the API simpler.
642* New examples make it easier to learn to use the package
643 (https://github.com/bos/aeson/tree/master/examples).
647 `aeson`'s support for data-type generic programming makes it
648 possible to use JSON encodings of most data types without writing
649 any boilerplate instances.
651 Thanks to Bas Van Dijk, `aeson` now supports the two major schemes
652 for doing datatype-generic programming:
654 * the modern mechanism, built into GHC itself
655 (http://www.haskell.org/ghc/docs/latest/html/users_guide/generic-programming.html)
657 * the older mechanism, based on SYB (aka "scrap your
660 The modern GHC-based generic mechanism is fast and terse: in fact,
661 its performance is generally comparable in performance to
662 hand-written and TH-derived `ToJSON` and `FromJSON` instances. To
663 see how to use GHC generics, refer to `examples/Generic.hs`.
665 The SYB-based generics support lives in `Data.Aeson.Generic` and is
666 provided mainly for users of GHC older than 7.2. SYB is far slower
667 (by about 10x) than the more modern generic mechanism. To see how
668 to use SYB generics, refer to `examples/GenericSYB.hs`.
670* We switched the intermediate representation of JSON objects from
671 `Data.Map` to `Data.HashMap` which has improved type conversion
674* Instances of `ToJSON` and `FromJSON` for tuples are between 45% and 70%
679 This version of aeson makes explicit the decoupling between
680 *identifying* an element of a JSON document and *converting* it to
681 Haskell. See the `Data.Aeson.Parser` documentation for details.
683 The normal `aeson` `decode` function performs identification
684 strictly, but defers conversion until needed. This can result in
685 improved performance (e.g. if the results of some conversions are
686 never needed), but at a cost in increased memory consumption.
688 The new `decode'` function performs identification and conversion
689 immediately. This incurs an up-front cost in CPU cycles, but
690 reduces reduce memory consumption.
keysesc to close
- j k
- move down, up
- enter
- open
- esc
- back, or up a level
- 1 2 3 4
- readme, files, commits, refs
- /
- filter
- y
- copy the clone command
- c
- compare the chosen commit with another (or shift-click both)
- ?
- show or hide this list