!:3      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0 1 2  D(c) 2011-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableSafe3aeson Transform a 4 into a 5 while transforming the keys.6aeson#Transform the keys and values of a 5.7aesonTransform the keys of a 5.367 None_8 None8n(c) 2012-2016 Bryan O'Sullivan (c) 2011, 2012 Bas Van Dijk (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableSafe.4=?@ACHUVX9aesonHSimple extensible tuple type to simplify passing around many parameters.aesonA type-level indicator that ToJSON1 or  FromJSON1 is being derived generically.aesonA type-level indicator that ToJSON or FromJSON is being derived generically.9:;<=>?@ABCD91:1D(c) 2011-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableNone127MSX5aesonOptions for encoding keys with  and .aesonDFunction applied to keys. Its result is what goes into the encoded .Example/The following instances encode the constructor Bar to lower-case keys "bar". data Foo = Bar deriving E opts ::  opts = > {  = F } instance  ToJSONKey Foo where  toJSONKey = genericToJSONKey opts instance  FromJSONKey Foo where  fromJSONKey = genericFromJSONKey opts aeson7Specifies how to encode constructors of a sum datatype.aeson9A constructor will be encoded to an object with a field  7 which specifies the constructor tag (modified by the  ). If the constructor is a record the encoded record fields will be unpacked into this object. So make sure that your record doesn't have a field with the same label as the  . Otherwise the tag gets overwritten by the encoded value of that field! If the constructor is not a record the encoded constructor contents will be stored under the   field.aesonConstructor names won't be encoded. Instead only the contents of the constructor will be encoded as if the type had a single constructor. JSON encodings have to be disjoint for decoding to work properly.When decoding, constructors are tried in the order of definition. If some encodings overlap, the first one defined will succeed.Note:5 Nullary constructors are encoded as strings (using  r). Having a nullary constructor alongside a single field constructor that encodes to a string leads to ambiguity.Note: Only the last error is kept when decoding, so in the case of malformed JSON, only an error for the last constructor will be reported.aesonrA constructor will be encoded to an object with a single field named after the constructor tag (modified by the  9) which maps to the encoded contents of the constructor.aeson|A constructor will be encoded to a 2-element array where the first element is the tag of the constructor (modified by the  B) and the second element the encoded contents of the constructor. aesonEOptions that specify how to encode/decode your datatype to/from JSON.*Options can be set using record syntax on < with the fields below. aesonYFunction applied to field labels. Handy for removing common record prefixes for example. aeson]Function applied to constructor tags which could be handy for lower-casing them for example.aesonIf G& the constructors of a datatype, with allW nullary constructors, will be encoded to just a string with the constructor tag. If H& the encoding will always follow the .aesonIf G, record fields with a I6 value will be omitted from the resulting object. If H=, the resulting object will include those fields mapping to null.Note that this does not affect parsing: J1 fields are optional regardless of the value of , subject to the note below.NoteSetting  to G( only affects fields which are of type J  uniformly in the ToJSON instance. In particular, if the type of a field is declared as a type variable, it will not be omitted from the JSON object, unless the field is specialized upfront in the instance.The same holds for J fields being optional in the FromJSON instance.Example,The generic instance for the following type Fruit* depends on whether the instance head is Fruit a or Fruit (Maybe a). _data Fruit a = Fruit { apples :: a -- A field whose type is a type variable. , oranges :: J Int } deriving E2 -- apples required, oranges optional -- Even if  is then specialized to (Fruit (J a)). instance  a => m (Fruit a) -- apples optional, oranges optional -- In this instance, the field apples is uniformly of type (J a). instance  a =>  (Fruit (J a)) options ::   options = < {  = GB } -- apples always present in the output, oranges is omitted if I instance  a =>  (Fruit a) where  = 4 options -- both apples and oranges are omitted if I instance  a =>  (Fruit (J a)) where  =  options aeson7Specifies how to encode constructors of a sum datatype.aesonRHide the field name when a record constructor has only one field, like a newtype.aeson9Encode types with a single constructor as sums, so that  and  apply.aesonApplies only to  instances. If a field appears in the parsed object map, but does not appear in the target object, parsing will fail, with an error message indicating which fields were unknown.aesonA key/value pair for an  .aesonA newtype wrapper for KQ that uses the same non-standard serialization format as Microsoft .NET, whose  Ghttps://msdn.microsoft.com/en-us/library/system.datetime(v=vs.110).aspxSystem.DateTimeD type is by default serialized to JSON as in the following example: /Date(1302547608878)/8The number represents milliseconds since the Unix epoch.aesonAcquire the underlying value.aeson,A JSON value represented as a Haskell value.aesonA JSON "array" (sequence). aeson A JSON "object" (key/value map).!aesontA JSON parser. N.B. This might not fit your usual understanding of "parser". Instead you might like to think of !Q as a "parse result", i.e. a parser to which the input has already been applied.LaesonSuccess continuation.MaesonFailure continuation."aesonThe result of running a !.%aeson!The internal result of running a !.)aesonCElements of a JSON path used to describe the location of an error.*aeson9JSON path element of a key into an object, "object.key".+aeson=JSON path element of an index into an array, "array[index]".,aeson1Raise a parsing failure with some custom message.-aesonThe empty array.NaesonDetermines if the  is an empty . Note that:  isEmptyArray -..aesonThe empty object./aesonRun a !.0aesonRun a !.1aesonRun a ! with a J result type.2aesonRun a ! with an O( result type. If the parse fails, the P' payload will contain an error message.3aeson"Annotate an error message with a  &http://goessner.net/articles/JsonPath/JSONPath error location.4aeson Format a  &http://goessner.net/articles/JsonPath/JSONPath as a #, representing the root object as $.5aeson Format a  &http://goessner.net/articles/JsonPath/JSONPath as a 9 which represents the path relative to some root object.6aeson Create a  from a list of name/value Ks. If duplicate keys arise, earlier keys and their associated values win.7aeson!Add JSON Path context to a parserWhen parsing a complex structure, it helps to annotate (sub)parsers with context, so that if an error occurs, you can find its location. iwithObject "Person" $ \o -> Person <$> o .: "name" <?> Key "name" <*> o .: "age" <?> Key "age"/(Standard methods like '(.:)' already do this.)\With such annotations, if an error occurs, you will get a JSON Path location of that error. Since 0.108aeson If the inner Parser failed, modify the failure message using the provided function. This allows you to create more descriptive error messages. For example: pparseJSON (Object o) = modifyFailure ("Parsing of the Foo value failed: " ++) (Foo <$> o .: "someField") Since 0.6.2.09aeson If the inner !: failed, prepend the given string to the failure message. 9 s = 8 (s Q) :aeson-Throw a parser error with an additional path.;aesonLA handler function to handle previous errors and return to normal execution.<aesonDefault encoding  :   {   = id ,   = id ,  = True ,  = False ,  = = ,  = False ,  = False ,  = False } =aesonDefault   options: defaultTaggedObject =  {  & = "tag" ,  & = "contents" } >aesonDefault : defaultJSONKeyOptions =  {  = R } ?aesonConverts from CamelCase to another lower case, interspersing the character between all capital letters and their previous entries, except those capital letters that appear together, like API.(For use by Aeson template haskell calls. .camelTo '_' 'CamelCaseAPI' == "camel_case_api"@aesonBetter version of ? . Example where it works better: ]camelTo '_' 'CamelAPICase' == "camel_apicase" camelTo2 '_' 'CamelAPICase' == "camel_api_case"Saeson'The ordering is total, consistent with T innstance. However, nothing else about the ordering is specified, and it may change from environment to environment and version to version of either this package or its dependencies (hashable and 'unordered-containers').@  !"$#%&'()*+,-N./0123456789:;<=>?@D(c) 2011-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableNoneEAaesonParse any JSON value.The conversion of a parsed value to a Haskell value is deferred until the Haskell value is needed. This may improve performance if only a subset of the results of conversions are needed, but at a cost in thunk allocation.This function is an alias for Cr. In aeson 0.8 and earlier, it parsed only object or array types, in conformance with the now-obsolete RFC 4627.WarningmIf an object contains duplicate keys, only the first one will be kept. For a more flexible alternative, see D.BaesonParse any JSON value.This is a strict version of A which avoids building up thunks during parsing; it performs all conversions immediately. Prefer this version if most of the JSON data needs to be accessed.This function is an alias for Jr. In aeson 0.8 and earlier, it parsed only object or array types, in conformance with the now-obsolete RFC 4627.WarningmIf an object contains duplicate keys, only the first one will be kept. For a more flexible alternative, see K.Caeson!Parse any JSON value. Synonym of A.DaesonParse any JSON value.;This parser is parameterized by a function to construct an  [ from a raw list of key-value pairs, where duplicates are preserved. The pairs appear in  reverse order from the source.ExamplesA3 keeps only the first occurence of each key, using . A = D (U V W) E. keeps the last occurence of each key, using  (X R). E = D (U V  (X R)) F= keeps wraps all values in arrays to keep duplicates, using H. F = D (U . H) G4 fails if any object contains duplicate keys, using I. G = D I Eaeson Variant of A2 which keeps only the last occurence of every key.Faeson Variant of A! wrapping all object mappings in 1 to preserve key-value pairs with the same keys.Gaeson Variant of A3 which fails if any object contains duplicate keys.HaesonH kvs^ is an object mapping keys to arrays containing all associated values from the original list kvs.SfromListAccum [("apple", Bool True), ("apple", Bool False), ("orange", Bool False)]GfromList [("apple", [Bool False, Bool True]), ("orange", [Bool False])]Iaeson fromListNoDup kvs fails if kvs contains duplicate keys.JaesonStrict version of C . Synonym of B.KaesonStrict version of D.Laeson Variant of B2 which keeps only the last occurence of every key.Maeson Variant of B! wrapping all object mappings in 1 to preserve key-value pairs with the same keys.Naeson Variant of B3 which fails if any object contains duplicate keys.OaesonParse a quoted JSON string.Paeson'Parse a string without a leading quote.Yaeson\Grab the first 100 bytes from the non parsed portion and format to get nicer error messagesUaeson[Parse a top-level JSON value followed by optional whitespace and end-of-input. See also: A.Vaeson[Parse a top-level JSON value followed by optional whitespace and end-of-input. See also: B.ZaesonZThe only valid whitespace in a JSON document is space, newline, carriage return, and tab.WaesonParse a JSON number.ABCDEFGHIJKLMNOPQRSTUVWAUDEFGCOPWBVKLMNJQRSTHID(c) 2012-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableNone<ABCDEFGJKLMNOQRSTWACOWDEFGBJKLMNQRST(c) 2015-2016 Bryan O'SullivanBSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableSafe܁Xaeson<Like TimeOfDay, but using a fixed-width integer for seconds.XYZ[\](c) 2015-2016 Bryan O'SullivanBSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableSafeX[aesonParse a date of the form [+,-]YYYY-MM-DD.\aeson4Parse a two-digit integer (e.g. day of month, hour).]aesonParse a time of the form HH:MM[:SS[.SSS]].^aesonGParse a count of seconds, with the integer part being two digits long._aesonParse a time zone, and return IF if the offset from UTC is zero. (This makes some speedups possible.)`aeson#Parse a date and time, of the form YYYY-MM-DD HH:MM[:SS[.SSS]]$. The space may be replaced with a TT. The number of seconds is optional and may be followed by a fractional component.aaeson Behaves as b5, but converts any time zone offset into a UTC time.baeson5Parse a date with time zone info. Acceptable formats:YYYY-MM-DD HH:MM Z YYYY-MM-DD HH:MM:SS Z YYYY-MM-DD HH:MM:SS.SSS Z!The first space may instead be a T*, and the second space is optional. The Z represents UTC. The Z6 may be replaced with a time zone offset of the form +0000 or -08:00-, where the first two digits are hours, the :D is optional and the second two digits (also optional) are minutes.[]_`abNonecaeson,Run an attoparsec parser as an aeson parser.daesonParse a date of the form [+,-]YYYY-MM-DD.eaesonParse a time of the form HH:MM[:SS[.SSS]].faesonParse a time zone, and return IF if the offset from UTC is zero. (This makes some speedups possible.)gaeson#Parse a date and time, of the form YYYY-MM-DD HH:MM[:SS[.SSS]]$. The space may be replaced with a TT. The number of seconds is optional and may be followed by a fractional component.haeson Behaves as i5, but converts any time zone offset into a UTC time.iaeson5Parse a date with time zone info. Acceptable formats:YYYY-MM-DD HH:MM Z YYYY-MM-DD HH:MM:SS Z YYYY-MM-DD HH:MM:SS.SSS Z!The first space may instead be a T*, and the second space is optional. The Z represents UTC. The Z6 may be replaced with a time zone offset of the form +0000 or -08:00-, where the first two digits are hours, the :D is optional and the second two digits (also optional) are minutes.cdefghiNone"#%&'-.8=>?@AHPUVXSjaesonwConstructors need to be decoded differently depending on whether they're a record or not. This distinction is made by  ConsParseJSON.kaeson_List of all constructor names of an ADT, after a given conversion function. (Better inlining.)laesonq, after unwrapping the m1 constructor, now carrying the data type's name.^aesonLifting of the m# class to binary type constructors.!Instead of manually writing your ^ instance,  Data.Aeson.THT provides Template Haskell functions which will derive an instance at compile time.aaesonLifting of the m" class to unary type constructors.!Instead of manually writing your a9 instance, there are two options to do it automatically: Data.Aeson.TH provides Template Haskell functions which will derive an instance at compile time. The generated instance is optimized for your type so it will probably be more efficient than the following option.?The compiler can provide a default generic implementation for b. To use the second, simply add a  deriving n( clause to your datatype and declare a a= instance for your datatype without giving a definition for b. For example: '{-# LANGUAGE DeriveGeneric #-} import  GHC.Generics? data Pair a b = Pair { pairFst :: a, pairSnd :: b } deriving n instance m a => a (Pair a) If the default implementation doesn't give exactly the results you want, you can customize the generic decoding with only a tiny amount of effort, using t with your preferred  : customOptions = < {   = o   } instance m a => a (Pair a) where b = t customOptions eaesonThis type is related to ToJSONKeyFunction. If i is used in the j instance, then ToJSONKeyValue should be used in the  ToJSONKeyS instance. The other three data constructors for this type all correspond to  ToJSONKeyText. Strictly speaking, h is more powerful than g&, which is in turn more powerful than fJ. For performance reasons, these exist as three options instead of one.jaesonRead the docs for  ToJSONKeyf first. This class is a conversion in the opposite direction. If you have a newtype wrapper around pR, the recommended way to define instances is with generalized newtype deriving: Vnewtype SomeId = SomeId { getSomeId :: Text } deriving (Eq,Ord,Hashable,FromJSONKey)UIf you have a sum of nullary constructors, you may use the generic implementation: =data Color = Red | Green | Blue deriving Generic instance j Color where k = x > kaeson5Strategy for parsing the key of a map-like container.laeson!This is similar in spirit to the q method of r". It makes it possible to give ) keys special treatment without using OverlappingInstancesV. End users should always be able to use the default implementation of this method.maesonIA type that can be converted from JSON, with the possibility of failure.In many cases, you can get the compiler to generate parsing code for you (see below). To begin, let's cover writing an instance by hand.EThere are various reasons a conversion could fail. For example, an  % could be missing a required key, an J could be of the wrong size, or a value could be of an incompatible type.<The basic ways to signal a failed conversion are as follows:sR yields a custom error message: it is the recommended way of reporting a failure;!" (or #$I) is uninformative: use it when the error is meant to be caught by some (t);y_ can be used to report a failure when the encountered value is not of the expected JSON type; zp is an appropriate alternative when more than one type may be expected, or to keep the expected type implicit.9 (or 85) add more information to a parser's error messages.#An example type and instance using y and 9: -- Allow ourselves to write pi literals. {-# LANGUAGE OverloadedStrings #-} data Coord = Coord { x :: Double, y :: Double } instance m Coord where n (  v) = Coord u v  "x" v v $ "y" -- We do not expect a non- ! value here. -- We could use !" to fail, but y9 -- gives a much more informative error message. n invalid = 9' "parsing Coord failed, " (y "Object" invalid) ^For this common case of only being concerned with a single type of JSON value, the functions ~, d, etc. are provided. Their use is to be preferred when possible, since they are more terse. Using ~], we can rewrite the above instance (assuming the same language extension and data type) as:  instance m Coord where n = ~ "Coord" $ \v -> Coord u v  "x" v v  "y" !Instead of manually writing your m9 instance, there are two options to do it automatically: Data.Aeson.TH provides Template Haskell functions which will derive an instance at compile time. The generated instance is optimized for your type so it will probably be more efficient than the following option.?The compiler can provide a default generic implementation for n. To use the second, simply add a  deriving E( clause to your datatype and declare a m= instance for your datatype without giving a definition for n.<For example, the previous example can be simplified to just: '{-# LANGUAGE DeriveGeneric #-} import  GHC.Generics; data Coord = Coord { x :: Double, y :: Double } deriving E instance m Coord 2The default implementation will be equivalent to  parseJSON = s <U; if you need different options, you can customize the generic decoding by defining: customOptions = < {   = o   } instance m Coord where n = s customOptions paesonA p" value either stores nothing (for m_) or it stores the two function arguments that decode occurrences of the type parameter (for a).qaesonFClass of generic representation types that can be converted from JSON.waesonThis method (applied to <4) is used as the default generic implementation of n (if the arity is ) or b (if the arity is ).saeson?A configurable generic JSON decoder. This function applied to < is used as the default for n" when the type is an instance of E.taeson?A configurable generic JSON decoder. This function applied to < is used as the default for b" when the type is an instance of n.uaeson Construct e for types coercible from p'. This conversion is still unsafe, as x and T instances of a should be compatible with pn i.e. hash values should be equal for wrapped values as well. This property will always be maintained if the x and TL instances are derived with generalized newtype deriving. compatible with p6 i.e. hash values be equal for wrapped values as well./On pre GHC 7.8 this is unconstrainted function.vaesonSemantically the same as 0coerceFromJSONKeyFunction = fmap coerce = coerce. See note on u.waesonSame as y$. Provided for the consistency with ToJSONKeyFunction.xaesonk for En types. These types must be sums of nullary constructors, whose names will be used as keys for JSON objects. See also genericToJSONKey.Example +data Color = Red | Green | Blue deriving E instance j Color where k = x > yaeson@Fail parsing due to a type mismatch, with a descriptive message.6The following wrappers should generally be prefered: ~, , , .Error message example YtypeMismatch "Object" (String "oops") -- Error: "expected Object, but encountered String"zaesonJFail parsing due to a type mismatch, when the expected types are implicit.Error message example 8unexpected (String "oops") -- Error: "unexpected String"zaeson3JSON type of a value, name of the head constructor.{aesonLift the standard n' function through the type constructor.|aesonLift the standard n' function through the type constructor.}aesonHelper function to use with b. See %&.{aesonUAdd context to a failure message, indicating the name of the structure being parsed. cprependContext "MyType" (fail "[error message]") -- Error: "parsing MyType failed, [error message]"~aeson~ name f value applies f to the   when value is an ' and fails otherwise.Error message example pwithObject "MyType" f (String "oops") -- Error: "parsing MyType failed, expected Object, but encountered String"aeson name f value applies f to the p when value is a ( and fails otherwise.Error message example awithText "MyType" f Null -- Error: "parsing MyType failed, expected String, but encountered Null"aeson expected f value applies f to the  when value is an ) and fails otherwise.Error message example nwithArray "MyType" f (String "oops") -- Error: "parsing MyType failed, expected Array, but encountered String"aeson name f value applies f to the | number when value is a * and fails using y otherwise.WarningH: If you are converting from a scientific to an unbounded type such as }E you may want to add a restriction on the size of the exponent (see ~N) to prevent malicious input from filling up the memory of the target system.Error message example twithScientific "MyType" f (String "oops") -- Error: "parsing MyType failed, expected Number, but encountered String"aeson A variant of  which doesn't use {b, so that such context can be added separately in a way that also applies when the continuation f :: Scientific -> Parser a fails.WarningH: If you are converting from a scientific to an unbounded type such as }E you may want to add a restriction on the size of the exponent (see ~N) to prevent malicious input from filling up the memory of the target system.Error message examples withScientific' f (String "oops") -- Error: "unexpected String" prependContext "MyType" (withScientific' f (String "oops")) -- Error: "parsing MyType failed, unexpected String"~aeson~ name f value applies f to the | number when value is a * with exponent less than or equal to 1024.aeson A variant of ~ which doesn't use {b, so that such context can be added separately in a way that also applies when the continuation f :: Scientific -> Parser a fails.aeson A variant of . parameterized by a function to apply to the ! in case of failure.aeson expected f value applies f to the  when value is a Boolean and fails otherwise.Error message example owithBool "MyType" f (String "oops") -- Error: "parsing MyType failed, expected Boolean, but encountered String"aeson$Decode a nested JSON-encoded string.aeson=Convert a value from JSON, failing if the types do not match.aeson=Convert a value from JSON, failing if the types do not match.aeson7Retrieve the value associated with the given key of an  . The result is emptyQ if the key is not present or the value cannot be converted to the desired type.2This accessor is appropriate if the key and value mustW be present in an object for it to be valid. If the key and value are optional, use  instead.aeson7Retrieve the value associated with the given key of an  . The result is I. if the key is not present or if its value is , or empty6 if the value cannot be converted to the desired type.This accessor is most useful if the key and value can be absent from an object without affecting its validity. If the key and value are mandatory, use  instead.aeson7Retrieve the value associated with the given key of an  . The result is I if the key is not present or empty7 if the value cannot be converted to the desired type.This differs from  by attempting to parse B the same as any other JSON value, instead of interpreting it as I.aesonFunction variant of .aesonFunction variant of .aesonFunction variant of .aeson Variant of  with explicit parser function.E.g.  { :: (a f, m a) ->   -> p -> ! (f a)aeson Variant of  with explicit parser function.aeson Variant of  with explicit parser function.aeson#Helper for use in combination with < to provide default values for optional JSON object fields.This combinator is most useful if the key and value can be absent from an object without affecting its validity and we know a default value to assign in that case. If the key and value are mandatory, use  instead.Example usage:  v1 <- o 1 "opt_field_with_dfl" .!= "default_val" v2 <- o  "mandatory_field" v3 <- o  "opt_field2" aesonCAdd the name of the type being parsed to a parser's error messages.aesonAdd the tagKey that will be looked up while building an ADT | Produce the error equivalent to | Left "Error in $: parsing T failed, expected an object with keys "tag" and | "contents", where "tag" i-- |s associated to one of [Foo, Bar=], | The parser returned error was: could not find key "tag"aesonJAdd the name of the constructor being parsed to a parser's error messages.aesonRender a constructor as "MyType(MyConstructor)".aesonFail with an informative error message about a mismatched tag. The error message is parameterized by the list of expected tags, to be inferred from the result type of the parser.aesonList of all constructor tags.aesonaesonaesonaesonaesonaesonThis instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype |& and provide your own instance using $ if you want to allow larger inputs.aesonThis instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype |& and provide your own instance using $ if you want to allow larger inputs.aesonSupported string formats:YYYY-MM-DD HH:MM Z YYYY-MM-DD HH:MM:SS Z YYYY-MM-DD HH:MM:SS.SSS Z!The first space may instead be a T*, and the second space is optional. The Z represents UTC. The Z6 may be replaced with a time zone offset of the form +0000 or -08:00-, where the first two digits are hours, the :D is optional and the second two digits (also optional) are minutes.aesonaesonThis instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype |& and provide your own instance using $ if you want to allow larger inputs.aesonThis instance includes a bounds check to prevent maliciously large inputs to fill up the memory of the target system. You can newtype |& and provide your own instance using $ if you want to allow larger inputs.aeson%Only law abiding up to interpretationaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonMultiple constructors.aesonSingle constructor.faesonuses gaesonconversion from p that always succeedshaesonconversion from p that may failiaesonconversion for non-textual keysyaeson)The name of the JSON type being parsed ("Object", "Array", "String", "Number",  "Boolean", or "Null").aesonThe actual value encountered.6^_`abcdeifghjklmnopqwrstuvwxyz{|}~(c) 2015-2016 Bryan O'SullivanBSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableNone4 %&'()*+037 %&')*+(730(c) 2015-2016 Bryan O'SullivanBSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableSafe;XYZ[\]XY[Z\]+O(c) 2011 MailRank, Inc. (c) 2013 Simon Meier <iridcode@gmail.com>BSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableNoneP aesonEncode a JSON value to a Data.ByteString .{Use this function if you are encoding over the wire, or need to prepend or append further bytes to the encoded JSON value.aesonEncode a JSON null.aesonEncode a JSON boolean.aesonEncode a JSON array.aesonEncode a JSON string.aeson/Encode a JSON string, without enclosing quotes.aeson Add quotes surrounding a builderaesonEncode a JSON string.aesonEncode a JSON number.None2SX aeson"Type tag for tuples contents, see .aeson[A series of values that, when encoded, should be separated by commas. Since 0.11.0.0, the .=* operator is overloaded to create either  (Text, Value) or b. You can use Series when encoding directly to a bytestring builder as in the following example: EtoEncoding (Person name age) = pairs ("name" .= name <> "age" .= age)aesonOften used synonym for .aesonAn encoding of a JSON value.tagF represents which kind of JSON the Encoding is encoding to, we reuse p and  as tags here.aeson*Acquire the underlying bytestring builder.aesonMake Encoding from Builder.WUse with care! You have to make sure that the passed Builder is a valid JSON Encoding!aeson8Encode a series of key/value pairs, separated by commas.aesonEncode as JSON objectaesonSee .aesonEncode as a tuple._@ toEncoding (X a b c) = tuple $ toEncoding a >*< toEncoding b >*< toEncoding caeson key encodingaesonvalue encodingaeson foldrWithKey - indexed foldaeson containerHH66,None [66-None"#&'-8=>?@ACHUVX6aesonLike . but the value is already converted to JSON ( or X), and the result actually represents lists of pairs so it can be readily concatenated.aeson"Wrap a list of pairs as an object.aeson2Get the name of the constructor of a sum datatype.aesonLifting of the # class to binary type constructors.!Instead of manually writing your  instance,  Data.Aeson.THT provides Template Haskell functions which will derive an instance at compile time.AThe compiler cannot provide a default generic implementation for  , unlike  and .aesonLifting of the " class to unary type constructors.!Instead of manually writing your 9 instance, there are two options to do it automatically: Data.Aeson.TH provides Template Haskell functions which will derive an instance at compile time. The generated instance is optimized for your type so it will probably be more efficient than the following option.?The compiler can provide a default generic implementation for . To use the second, simply add a  deriving n( clause to your datatype and declare a < instance for your datatype without giving definitions for  or . For example: '{-# LANGUAGE DeriveGeneric #-} import  GHC.Generics; data Pair = Pair { pairFst :: a, pairSnd :: b } deriving n instance  a =>  (Pair a) If the default implementation doesn't give exactly the results you want, you can customize the generic encoding with only a tiny amount of effort, using  and  with your preferred  : customOptions = < {   = o   } instance  a =>  (Pair a) where  =  customOptions  =  customOptions  See also .aeson)key is encoded to string, produces objectaeson'key is encoded to value, produces arrayaesonQTypeclass for types that can be used as the key of a map-like container (like Map or HashMap). For example, since p has a  instance and  has a , instance, we can encode a value of type Map p :<LBC8.putStrLn $ encode $ Map.fromList [("foo" :: Text, 'a')] {"foo":"a"}Since  also has a " instance, we can similarly write:7LBC8.putStrLn $ encode $ Map.fromList [(5 :: Int, 'a')] {"5":"a"}HJSON documents only accept strings as object keys. For any type from baseK that has a natural textual representation, it can be expected that its * instance will choose that representation.For data types that lack a natural textual representation, an alternative is provided. The map-like container is represented as a JSON array instead of a JSON object. Each value in the array is an array with exactly two values. The first is the key and the second is the value.LFor example, values of type '[Text]' cannot be encoded to a string, so a Map2 with keys of type '[Text]' is encoded as follows:JLBC8.putStrLn $ encode $ Map.fromList [(["foo","bar","baz" :: Text], 'a')][[["foo","bar","baz"],"a"]]The default implementation of 5 chooses this method of encoding a key, using the  instance of the type.STo use your own data type as the key in a map, all that is needed is to write a  (and possibly a  FromJSONKeyL) instance for it. If the type cannot be trivially converted to and from p, it is recommended that a is used. Since the default implementations of the typeclass methods can build this from a 5 instance, there is nothing that needs to be written: xdata Foo = Foo { fooAge :: Int, fooName :: Text } deriving (Eq,Ord,Generic) instance ToJSON Foo instance ToJSONKey FooThat's it. We can now write::let m = Map.fromList [(Foo 4 "bar",'a'),(Foo 6 "arg",'b')]LBC8.putStrLn $ encode mG[[{"fooName":"bar","fooAge":4},"a"],[{"fooName":"arg","fooAge":6},"b"]]SThe next case to consider is if we have a type that is a newtype wrapper around pE. The recommended approach is to use generalized newtype deriving: Qnewtype RecordId = RecordId { getRecordId :: Text } deriving (Eq,Ord,ToJSONKey)Then we may write:<LBC8.putStrLn $ encode $ Map.fromList [(RecordId "abc",'a')] {"abc":"a"}ESimple sum types are a final case worth considering. Suppose we have: =data Color = Red | Green | Blue deriving (Show,Read,Eq,Ord)It is possible to get the % instance for free as we did with FooD. However, in this case, we have a natural way to go to and from p3 that does not require any escape sequences. So  can be used instead of x to encode maps as objects instead of arrays of pairs. This instance may be implemented using generics as follows:  instance  Color where  =  > Low-level implementationsThe $ instance can be used to help write : instance ToJSONKey Color where toJSONKey = ToJSONKeyText f g where f = Text.pack . show g = text . Text.pack . show -- text function is from Data.Aeson.Encoding-The situation of needing to turning function  a -> Text into a j is common enough that a special combinator is provided for it. The above instance can be rewritten as: Minstance ToJSONKey Color where toJSONKey = toJSONKeyText (Text.pack . show)FThe performance of the above instance can be improved by not using / as an intermediate step when converting to p^. One option for improving performance would be to use template haskell machinery from the  text-show2 package. However, even with the approach, the I (a wrapper around a bytestring builder) is generated by encoding the p to a  ByteStringa, an intermediate step that could be avoided. The fastest possible implementation would be: C-- Assuming that OverloadedStrings is enabled instance ToJSONKey Color where toJSONKey = ToJSONKeyText f g where f x = case x of {Red -> "Red";Green ->"Green";Blue -> "Blue"} g x = case x of {Red -> text "Red";Green -> text "Green";Blue -> text "Blue"} -- text function is from Data.Aeson.EncodingThis works because GHC can lift the encoded values out of the case statements, which means that they are only evaluated once. This approach should only be used when there is a serious need to maximize performance.aeson8Strategy for rendering the key for a map-like container.aeson!This is similar in spirit to the  showsList method of ". It makes it possible to give ) keys special treatment without using OverlappingInstancesV. End users should always be able to use the default implementation of this method.aeson,A key-value pair for encoding a JSON object.aeson%A type that can be converted to JSON.Instances in general must specify  and should (but don't need to) specify .An example type and instance: -- Allow ourselves to write pi literals. {-# LANGUAGE OverloadedStrings #-} data Coord = Coord { x :: Double, y :: Double } instance  Coord where  (Coord x y) = 6 ["x"  x, "y"  y]  (Coord x y) = pairs ("x"  x  "y"  y) !Instead of manually writing your 9 instance, there are two options to do it automatically: Data.Aeson.TH provides Template Haskell functions which will derive an instance at compile time. The generated instance is optimized for your type so it will probably be more efficient than the following option.?The compiler can provide a default generic implementation for . To use the second, simply add a  deriving E( clause to your datatype and declare a . instance. If you require nothing other than <Q, it is sufficient to write (and this is the only alternative where the default  implementation is sufficient): '{-# LANGUAGE DeriveGeneric #-} import  GHC.Generics; data Coord = Coord { x :: Double, y :: Double } deriving E instance  Coord where  =  < eIf on the other hand you wish to customize the generic decoding, you have to implement both methods: customOptions = < {   = o   } instance  Coord where  =  customOptions  =  customOptions /Previous versions of this library only had the  method. Adding  had two reasons: EtoEncoding is more efficient for the common case that the output of  is directly serialized to a  ByteStringQ. Further, expressing either method in terms of the other would be non-optimal.mThe choice of defaults allows a smooth transition for existing users: Existing instances that do not define i still compile and have the correct semantics. This is ensured by making the default implementation of  use Y. This produces correct results, but since it performs an intermediate conversion to a 6, it will be less efficient than directly emitting an 7. (this also means that specifying nothing more than instance ToJSON Coords would be sufficient as a generically decoding instance, but there probably exists no good reason to not specify  in new instances.)aeson=Convert a Haskell value to a JSON-friendly intermediate type.aesonEncode a Haskell value as JSON.CThe default implementation of this method creates an intermediate  using . This provides source-level compatibility for people upgrading from older versions of this library, but obviously offers no performance advantage.%To benefit from direct encoding, you mustj provide an implementation for this method. The easiest way to do so is by having your types implement E using the  DeriveGenericA extension, and then have GHC generate a method body as follows.  instance  Coord where  =  < aesonA " value either stores nothing (for _) or it stores the two function arguments that encode occurrences of the type parameter (for ).aesonEClass of generic representation types that can be converted to JSON.aesonThis method (applied to <4) is used as the default generic implementation of  (with enc ~  and arity ~ ) and  (if the arity is ).-It also provides a generic implementation of  (with enc ~  and arity ~ ) and  (if the arity is ).aeson?A configurable generic JSON creator. This function applied to < is used as the default for " when the type is an instance of E.aeson?A configurable generic JSON creator. This function applied to < is used as the default for " when the type is an instance of n.aeson?A configurable generic JSON encoder. This function applied to < is used as the default for " when the type is an instance of E.aeson?A configurable generic JSON encoder. This function applied to < is used as the default for " when the type is an instance of n.aeson!Helper for creating textual keys.  instance  MyKey where  = [ myKeyToText where myKeyToText = Text.pack . show -- or showt from text-show aesonTODO: should this be exported?aesonContravariant map, as  is a contravariant functor.aesonLift the standard ' function through the type constructor.aesonLift the standard ' function through the type constructor.aesonLift the standard ' function through the type constructor.aesonLift the standard ' function through the type constructor.aesonHelper function to use with . Useful when writing own  instances. .newtype F a = F [a] -- This instance encodes  as an array of chars instance  F where  tj _ (F xs) =  tj ( tj) xs  te _ (F xs) =  te ( te) xs instance ./ F where .0 p _ v = F <$> .0 p (.1 p) v aesonHelper function to use with , see .aeson!Encode something t a JSON string.aesonaesonaesonaesonaesonEncoded as numberaesonaesonaesonConstructs a singleton 5*. For calling functions that demand an  = for constructing objects. To be used in conjunction with . Prefer to use 6 where possible.aesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonindexaesonlength.82D(c) 2011-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableNone &',=>?@AXha^_`abcdeifghjklmnopqwstuvwxyz{|}~D(c) 2011-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableNoneϻaeson Encode a  as a JSON array.   !"$#()*+,-./12456789:;<=>?@^_`abcdeifghjklmnopqstuvwxyz{|}~- .yz!"$#mno/21,89:;jkleifghuvwdxabc{^_`|qpst~6}  ?@<=>7()*+45D(c) 2012-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableNonePaesonEncode a JSON  to a Data.Text.LazyNote: uses aesonEncode a JSON  to a  Data.Text >, which can be embedded efficiently in a text-based protocol.6If you are going to immediately encode straight to a 34, it is more efficient to use encode (lazy ByteString) or  fromEncoding .  (ByteString.Builder) instead.Note: Uses D(c) 2011-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableNone aeson-Efficiently serialize a JSON value as a lazy .$This is implemented in terms of the  class's  method. aeson-Efficiently serialize a JSON value as a lazy  and write it to a file. aeson1Efficiently deserialize a JSON value from a lazy 5. If this fails due to incomplete or invalid input, I is returned._The input must consist solely of a JSON document, with no trailing data except for whitespace.?This function parses immediately, but defers conversion. See A for details. aeson3Efficiently deserialize a JSON value from a strict 5. If this fails due to incomplete or invalid input, I is returned._The input must consist solely of a JSON document, with no trailing data except for whitespace.?This function parses immediately, but defers conversion. See A for details. aesoneEfficiently deserialize a JSON value from a file. If this fails due to incomplete or invalid input, I is returned.nThe input file's content must consist solely of a JSON document, with no trailing data except for whitespace.?This function parses immediately, but defers conversion. See A for details.aeson1Efficiently deserialize a JSON value from a lazy 5. If this fails due to incomplete or invalid input, I is returned._The input must consist solely of a JSON document, with no trailing data except for whitespace.@This function parses and performs conversion immediately. See B for details.aeson3Efficiently deserialize a JSON value from a strict 5. If this fails due to incomplete or invalid input, I is returned._The input must consist solely of a JSON document, with no trailing data except for whitespace.@This function parses and performs conversion immediately. See B for details.aesoneEfficiently deserialize a JSON value from a file. If this fails due to incomplete or invalid input, I is returned.nThe input file's content must consist solely of a JSON document, with no trailing data except for whitespace.@This function parses and performs conversion immediately. See B for details.aesonLike  2 but returns an error message when decoding fails.aesonLike  2 but returns an error message when decoding fails.aesonLike  2 but returns an error message when decoding fails.aesonLike 2 but returns an error message when decoding fails.aesonLike 2 but returns an error message when decoding fails.aesonLike 2 but returns an error message when decoding fails.   "$#(67<=>@AB^_`abcdeifghjklmnopqrstx{|~           mno"$#7(jkleifghdxabc{^_`|qpst <  @=>~6ABrC(c) 2011-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3 experimentalportableNone$=?cFaesonEWhether a type is not of kind *, is of kind *, or is a kind variable.aeson5A representation of which typeclass is being derived.aeson0A refinement of JSONFun to [ToJSON, ToEncoding].aeson?A representation of which typeclass method is being spliced in.aeson8Whether ToJSON(1)(2) or FromJSON(1)(2) is being derived.aesonMA representation of the arity of the ToJSON/FromJSON typeclass being derived.aesonGenerates both  and mT instance declarations for the given data type or data family instance constructor.EThis is a convienience function which is equivalent to calling both  and #.aesonGenerates both  and aT instance declarations for the given data type or data family instance constructor.EThis is a convienience function which is equivalent to calling both  and $.aesonGenerates both  and ^T instance declarations for the given data type or data family instance constructor.EThis is a convienience function which is equivalent to calling both  and %.aeson Generates a S instance declaration for the given data type or data family instance constructor.aeson Generates a S instance declaration for the given data type or data family instance constructor.aeson Generates a S instance declaration for the given data type or data family instance constructor.aesonjGenerates a lambda expression which encodes the given data type or data family instance constructor as a .aesonjGenerates a lambda expression which encodes the given data type or data family instance constructor as a Q by using the given encoding function on occurrences of the last type parameter.aesonjGenerates a lambda expression which encodes the given data type or data family instance constructor as a W by using the given encoding functions on occurrences of the last two type parameters. aesonvGenerates a lambda expression which encodes the given data type or data family instance constructor as a JSON string.!aesonGenerates a lambda expression which encodes the given data type or data family instance constructor as a JSON string by using the given encoding function on occurrences of the last type parameter."aesonGenerates a lambda expression which encodes the given data type or data family instance constructor as a JSON string by using the given encoding functions on occurrences of the last two type parameters.aesonHelper function used by both  and  . Generates code to generate a  or K of a number of constructors. All constructors must be from the same type.aeson$Name of the constructor as a quoted  or .aeson$Name of the constructor as a quoted Text.aesonName of the constructor.aesonIf constructor is nullary.aeson-Wrap fields of a non-record constructor. See .aeson)Wrap fields of a record constructor. See .aesonWrap fields of a constructor.aesonEGenerates code to generate the JSON encoding of a single constructor.aesonWrap a list of quoted s in a quoted  (of type ).aeson?Wrap an associative list of keys and quoted values in a quoted  .aeson a list of fixed length. 6mconcatE [ [|x|], [|y|], [|z|] ] = [| x <> (y <> z) |]aeson)Create (an encoding of) a key-value pair.  pairE "k" [|v|] = [|pair "k" v|]#aeson Generates a mS instance declaration for the given data type or data family instance constructor.$aeson Generates a aS instance declaration for the given data type or data family instance constructor.%aeson Generates a ^S instance declaration for the given data type or data family instance constructor.&aesonyGenerates a lambda expression which parses the JSON encoding of the given data type or data family instance constructor.'aesonGenerates a lambda expression which parses the JSON encoding of the given data type or data family instance constructor by using the given parsing function on occurrences of the last type parameter.(aesonGenerates a lambda expression which parses the JSON encoding of the given data type or data family instance constructor by using the given parsing functions on occurrences of the last two type parameters.aesonHelper function used by both # and &w. Generates code to parse the JSON encoding of a number of constructors. All constructors must be from the same type.aesonBGenerates code to parse the JSON encoding of a single constructor.aesonCGenerates code to parse the JSON encoding of an n-ary constructor.aesonFunctionality common to , , and .aesonFunctionality common to deriveToJSON(1)(2) and deriveFromJSON(1)(2).aesonAttempt to derive a constraint on a Type. If successful, return Just the constraint and any kind variable names constrained to *. Otherwise, return Nothing and the empty list.dSee Note [Type inference in derived instances] for the heuristics used to come up with constraints.aeson"Returns True if a Type has kind *.aesonhasKindVarChain n kind Checks if kindj is of the form k_0 -> k_1 -> ... -> k_(n-1), where k0, k1, ..., and k_(n-1) can be * or kind variables.aesonEIf a Type is a SigT, returns its kind signature. Otherwise, return *.aesoniExtract Just the Name from a type variable. If the argument Type is not a type variable, return Nothing.aesondExtract the Name from a type variable. If the argument Type is not a type variable, throw an error.aeson7Fully applies a type constructor to its type variables. aesonIs the given type a variable? aesonyDetect if a Name in a list of provided Names occurs as an argument to some type family. This makes an effort to exclude  oversaturatedV arguments to type families. For instance, if one declared the following type family:  type family F a :: Type -> Type Then in the type F a b, we would consider a to be an argument to F , but not b. aeson6Peel off a kind signature from a Type (if it has one). aesonAAre all of the items in a list (which have an ordering) distinct?HThis uses Set (as opposed to nub) for better asymptotic time complexity. aeson9Does the given type mention any of the Names in the list?aeson@Does an instance predicate mention any of the Names in the list?aesonHSplit an applied type into its individual components. For example, this: Either Int Char would split to this: [Either, Int, Char] aesonESplit a type signature by the arrows on its spine. For example, this: .forall a b. (a ~ b) => (a -> b) -> Char -> () would split to this: (a ~ b, [a -> b, Char, ()]) aeson)Like uncurryType, except on a kind level.aeson<Makes a string literal expression from a constructor's name.aesonExtracts a record field label.aesonThe name of the outermost  constructor.aesonChecks to see if the last types in a data family instance can be safely eta- reduced (i.e., dropped), given the other types. This checks for three conditions: +All of the dropped types are type variables%All of the dropped types are distinct<None of the remaining types mention any of the dropped typesaesonEither the given data type doesn't have enough type variables, or one of the type variables to be eta-reduced cannot realize kind *.aeson}One of the last type variables cannot be eta-reduced (see the canEtaReduce function for the criteria it would have to meet).aesonZThe data type has a DatatypeContext which mentions one of the eta-reduced type variables.aesonThe data type mentions one of the n eta-reduced type variables in a place other than the last nth positions of a data type in a constructor's field.aesonbThe data type has an existential constraint which mentions one of the eta-reduced type variables.aeson8Does a Type have kind * or k (for some kind variable k)?aesonReturns  the kind variable  of a # if it exists. Otherwise, returns I.aesonjConcat together all of the StarKindStatuses that are IsKindVar and extract the kind variables' Names out.!aesonEncoding options.aeson'Name of the type for which to generate  and m instances.aesonEncoding options.aeson'Name of the type for which to generate  and a instances.aesonEncoding options.aeson'Name of the type for which to generate  and ^ instances.aesonEncoding options.aeson)Name of the type for which to generate a  instance declaration.aesonEncoding options.aeson)Name of the type for which to generate a  instance declaration.aesonEncoding options.aeson)Name of the type for which to generate a  instance declaration. aeson!The ToJSON variant being derived.aesonEncoding options.aeson3Name of the type for which to generate an instance.aesonEncoding options.aesonName of the type to encode.aesonEncoding options.aesonName of the type to encode.aesonEncoding options.aesonName of the type to encode.!aeson&Which class's method is being derived.aesonEncoding options.aesonName of the encoded type. aesonEncoding options.aesonName of the type to encode.!aesonEncoding options.aesonName of the type to encode."aesonEncoding options.aesonName of the type to encode."aeson&Which class's method is being derived.aesonEncoding options.aesonName of the encoded type.aeson The method ( or ) being derived.aeson!The ToJSON variant being derived.aesonEncoding options.aeson=The types from the data type/data family instance declarationaeson8Constructors for which to generate JSON generating code.aesonThe method being derived.aesonDeriving options.aeson*Does this type have multiple constructors.aesonIs this constructor nullary.aesonConstructor name.aesonFields of the constructor as a  or .aesonRepresentation of an   fragment used for the  variant; of type [(Text,Value)] or  [Encoding]), depending on the method being derived.!For non-records, produces a pair "contentsFieldName":value , given a contentsFieldName as an argument. See .tFor records, produces the list of pairs corresponding to fields of the encoded value (ignores the argument). See .#aesonEncoding options.aeson)Name of the type for which to generate a m instance declaration.$aesonEncoding options.aeson)Name of the type for which to generate a a instance declaration.%aesonEncoding options.aeson)Name of the type for which to generate a  FromJSON3 instance declaration.#aeson#The FromJSON variant being derived.aesonEncoding options.aesonAName of the type for which to generate an instance. declaration.&aesonEncoding options.aesonName of the encoded type.'aesonEncoding options.aesonName of the encoded type.(aesonEncoding options.aesonName of the encoded type.$aeson&Which class's method is being derived.aesonEncoding options.aesonName of the encoded type.aeson#The FromJSON variant being derived.aeson2Name of the type to which the constructors belong.aesonEncoding optionsaeson=The types from the data type/data family instance declarationaeson5Constructors for which to generate JSON parsing code.aeson#The FromJSON variant being derived.aesonEMaps the last type variables to their decoding function arguments.aeson2Name of the type to which the constructor belongs.aesonEncoding options.aeson4Constructor for which to generate JSON parsing code.aeson0Left (valFieldName, objName) or Right valNameaeson#The FromJSON variant being derived.aesonEMaps the last type variables to their decoding function arguments.aeson&The argument types of the constructor.aeson2Name of the type to which the constructor belongs.aeson%structor name.aeson%structor arity.aeson#Function which derives a flavor of .aeson#Function which derives a flavor of m.aesonEncoding options.aeson'Name of the type for which to generate  and m instances.aeson6The class methods and the functions which derive them.aeson,The class for which to generate an instance.aesonEncoding options.aesonEName of the type for which to generate a class instance declaration.&aeson*The function which derives the expression.aeson&Which class's method is being derived.aesonEncoding options.aesonName of the encoded type.'aeson(The type constructor or data family nameaesonThe typeclass to deriveaesonThe datatype contextaeson*The types to instantiate the instance withaeson1Are we dealing with a data family instance or notaesonEncoding options$ <= !"#$%&'($  <=#$% !"&'((6)4 None00 D(c) 2012-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableNone&1212*56789:;<=>?@ABCDEFGHIJJKL')(*MN)'OPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~/01L"q---------- - - - - ----------------------- -&-!2"2#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLM N ' & OPQRSTU V W XYYZ[\]^__`abcdecfghi^hi]cjkcjlmnoRpqcrscrtcuvcuwxhyzcr{cu|S}cu~cdcdcuccccuccucuh++++++++++d++++++++++---hihiccu-----------cu--------------------c44      !"#$%&'()*+,-./01234567cj89:;<=>?@A9:BCDEFG$aeson-1.5.3.0-C0atVWm6U8ACelOzw2UBBCData.Aeson.TypesData.Aeson.InternalData.Aeson.Parser.InternalData.Aeson.Internal.Time Data.AesonData.Aeson.Encoding.InternalData.Aeson.Text Data.Aeson.THData.Aeson.QQ.SimpleData.Aeson.EncodeData.Aeson.Internal.FunctionsData.Aeson.Parser.UnescapePureData.Aeson.Parser.UnescapeData.Aeson.Types.GenericData.Aeson.Types.InternalgenericFromJSONKeygenericToJSONKeyfromJSONFromJSONToJSONtoJSON genericToJSON HashMap.LazyfromList fromListWithData.Aeson.ParserData.Attoparsec.Time.InternalData.Attoparsec.TimeData.Aeson.Parser.TimeData.Aeson.Types.FromJSON Data.ChartoUpperControl.Applicativeempty Control.MonadmzeroData.Aeson.ToJSON listEncodingObjectStringArrayNumberData.Aeson.Encoding.BuilderData.Aeson.EncodingData.Aeson.Types.ToJSONData.Aeson.FromJSON FromJSON1 liftParseJSON listParserData.Aeson.Types.ClassL ByteStringOneZeroJSONKeyOptions keyModifier SumEncoding TaggedObject UntaggedValueObjectWithSingleField TwoElemArray tagFieldNamecontentsFieldNameOptionsfieldLabelModifierconstructorTagModifierallNullaryToStringTagomitNothingFields sumEncodingunwrapUnaryRecordstagSingleConstructorsrejectUnknownFieldsPair DotNetTimefromDotNetTimeValueBoolNullParserResultErrorSuccessIResultIErrorISuccessJSONPathJSONPathElementKeyIndex parseFail emptyArray emptyObjectparseiparse parseMaybe parseEither formatError formatPathformatRelativePathobject modifyFailureprependFailureparserThrowErrorparserCatchErrordefaultOptionsdefaultTaggedObjectdefaultJSONKeyOptionscamelTocamelTo2jsonjson'valuejsonWithjsonLast jsonAccum jsonNoDup fromListAccumparseListNoDupvalue' jsonWith' jsonLast' jsonAccum' jsonNoDup'jstringjstring_ decodeWithdecodeStrictWitheitherDecodeWitheitherDecodeStrictWithjsonEOFjsonEOF' scientific TimeOfDay64TODtoPicofromPicodiffTimeOfDay64 toTimeOfDay64 FromJSON2liftParseJSON2liftParseJSONList2liftParseJSONList GFromJSONKeyFromJSONKeyFunctionFromJSONKeyCoerceFromJSONKeyTextFromJSONKeyTextParserFromJSONKeyValue FromJSONKey fromJSONKeyfromJSONKeyList parseJSON parseJSONListFromArgs GFromJSONparseIndexedJSONgenericParseJSONgenericLiftParseJSONfromJSONKeyCoercecoerceFromJSONKeyFunctionmapFromJSONKeyFunction typeMismatch unexpected parseJSON1 parseJSON2 withObjectwithText withArraywithScientificwithBoolwithEmbeddedJSON ifromJSON.:.:?.:! parseFieldparseFieldMaybeparseFieldMaybe'explicitParseFieldexplicitParseFieldMaybeexplicitParseFieldMaybe'.!=InArraySeriesEmptyEncoding Encoding' fromEncodingunsafeToEncodingencodingToLazyByteString retagEncodingpairpairStrpair' nullEncoding emptyArray_ emptyObject_ wrapArray wrapObjectnull_boolpairslistdict>*<econcat><tupletextlazyTextstringcommacolon openBracket closeBracket openCurly closeCurlyint8int16int32int64intword8word16word32word64wordintegerfloatdoubleint8Text int16Text int32Text int64TextintText word8Text word16Text word32Text word64TextwordText integerText floatText doubleTextscientificTextday localTimeutcTime timeOfDay zonedTime$fOrdEncoding' $fEqEncoding'$fShowEncoding'$fMonoidSeries$fSemigroupSeriesToJSON2 liftToJSON2liftToJSONList2liftToEncoding2liftToEncodingList2ToJSON1 liftToJSONliftToJSONListliftToEncodingliftToEncodingList GToJSONKeyToJSONKeyFunction ToJSONKeyTextToJSONKeyValue ToJSONKey toJSONKey toJSONKeyListKeyValue.= toEncoding toJSONListtoEncodingListToArgsGToJSON'genericLiftToJSONgenericToEncodinggenericLiftToEncoding toJSONKeyTextcontramapToJSONKeyFunctiontoJSON1 toEncoding1toJSON2 toEncoding2 listValue GToEncodingGToJSONfoldableencodeToLazyTextencodeToTextBuilderencode encodeFiledecode decodeStrictdecodeFileStrictdecode' decodeStrict'decodeFileStrict' eitherDecodeeitherDecodeStricteitherDecodeFileStrict eitherDecode'eitherDecodeStrict'eitherDecodeFileStrict' deriveJSON deriveJSON1 deriveJSON2 deriveToJSON deriveToJSON1 deriveToJSON2mkToJSON mkLiftToJSON mkLiftToJSON2 mkToEncodingmkLiftToEncodingmkLiftToEncoding2deriveFromJSONderiveFromJSON1deriveFromJSON2 mkParseJSONmkLiftParseJSONmkLiftParseJSON2$fLookupFieldOption$fLookupFieldMaybe$fLookupFielda $fEnumArity $fEqArity $fOrdArity$fEqStarKindStatusaesonQQ mapHashKeyValcontainers-0.6.0.1Data.Map.InternalMap4unordered-containers-0.2.12.0-7BikmbtnebBBqNM33KNnUdData.HashMap.InternalHashMap mapKeyValmapKey unescapeText:* ProductSize productSizeAndFalseTrueTagged2 unTagged2 AllNullaryIsRecordbase GHC.GenericsGeneric GHC.UnicodetoLowerghc-prim GHC.Types GHC.MaybeNothingMaybe time-1.8.0.2 Data.Time.Clock.Internal.UTCTimeUTCTimeFailure isEmptyArray Data.EitherEitherLeftGHC.Base++id $fOrdValue GHC.ClassesEqRight.Data.HashMap.Internal.StrictconstformatErrorLine skipSpace twoDigitssecondstimeZonerun ConsFromJSONConstructorNames GFromJSON'D1Generic1map text-1.2.3.1Data.Text.InternalTextGHC.ReadreadListReadControl.Monad.Failfail<|> Data.Functor<$><*> gParseJSON'hashable-1.3.0.0-1RsrIcitxVDKffGN1TuMlmData.Hashable.ClassHashablefmaptypeOfprependContext)scientific-0.3.6.2-HDoLkL8YC3O28Jlh4HmWvSData.Scientific Scientific integer-gmpGHC.Integer.TypeIntegerwithBoundedScientificwithScientific'withBoundedScientific'withBoundedScientific_ contextType contextTag contextConsshowCons failWithCTagsconstructorTags$fFromJSONThese$fFromJSONMaybe$fFromJSONEither$fFromJSONPair$fFromJSONThese0$fFromJSONDiffTime$fFromJSONNominalDiffTime$fFromJSONZonedTime$fFromJSONDNonEmpty$fFromJSONInteger$fFromJSONFixed$fFunctorFromJSONKeyFunction$fFromJSONThese1$fFromJSON1These1$fFromJSON1These$fFromJSON1Maybe$fFromJSON1Either$fFromJSON1Pair$fFromJSON1These0 $fFromJSONNu $fFromJSONMu $fFromJSONFix$fFromJSON1DNonEmpty$fFromJSON2These$fFromJSON2Either$fFromJSON2Pair$fFromJSON2These0$fGFromJSON'arity:+:$fGFromJSON'arityM1GHC.Primcoerce NoFromArgs From1ArgsparseOptionalFieldWithencodeToBuilderbytestring-0.10.8.2 Data.ByteString.Builder.InternalBuilderarrayunquotedquoteascii2ascii4ascii5 KeyValuePair FromPairs GetConNameCharIntGHC.ShowShow<>gToJSONtoJSONKeyTextEncstringEncoding $fToJSONMaybe$fToJSONEither $fToJSONPair $fToJSONThese$fToJSONSystemTime$fToJSONDNonEmpty$fToJSONThese0$fKeyValueHashMapmconcat$fToJSONThese1$fToJSON1These$fToJSON1Maybe$fToJSON1Either $fToJSON1Pair$fToJSON1These0 $fToJSONNu $fToJSONMu $fToJSONFix$fToJSON1DNonEmpty$fToJSON2These$fToJSON2Either $fToJSON2Pair$fToJSON2These0$fToJSON1These1 writeProduct fromPairsNoToArgsTo1Args Data.FoldableFoldableData.Text.Internal.BuilderData.ByteString.Lazy.InternalData.ByteString.InternalStarKindStatus JSONClass ToJSONFunJSONFun DirectionArity consToValueconStrconTxt conString isNullaryopaqueSumToValue sumToValuerecordSumToValue argsToValueobjectEmconcatEpairE consFromJSON parseArgs parseProductderiveJSONBothderiveJSONClassderiveConstraint hasKindStarhasKindVarChaintyKindvarTToNameMaybe varTToName applyTyConisTyVarisInTypeFamilyAppunSigT allDistinct mentionsNamepredMentionsName unapplyTy uncurryTy uncurryKind conNameExp fieldLabel valueConName canEtaReducederivingKindErroretaReductionErrordatatypeContextErroroutOfPlaceTyVarErrorexistentialContextErrorcanRealizeKindStarstarKindStatusToNameJusttemplate-haskellLanguage.Haskell.TH.SyntaxNamecatKindVarNamesderiveToJSONCommonmkToJSONCommonmkToEncodingCommonderiveFromJSONCommonmkParseJSONCommonCon mkFunCommonbuildTypeInstance<^><%>