h&C&.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                    " Safe-Inferred(c) 2011-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan  experimentalportable Safe-Inferred vaeson#Transform the keys and values of a .aeson#Transform the keys and values of a .aesonTransform the keys of a .aesonTransform the keys of a . Safe-Inferred 5 Safe-Inferred aesonParse  number from .This is different from how JSON numbers are parsed: arbitrary leading zeroes are accepted. Safe-Inferred taesonBetter letE.aesonwhat bindings areaeson/expression with a function to generate bindings Safe-Inferred aesonThe input is assumed to contain only 7bit ASCII characters (i.e. < 0x80). We use TE.decodeLatin1 here because TE.decodeASCII is currently (text-1.2.4.0) deprecated and equal to TE.decodeUtf8, which is slower than TE.decodeLatin1. Safe-InferredCaesonUnescape JSON text literal.This function is exporeted mostly for testing and benchmarking purposes. Safe-InferredaesonUnescape JSON text literal.This function is exporeted mostly for testing and benchmarking purposes. Safe-Inferred Safe-Inferredd Safe-Inferred)*6aeson'coercing r1 r2' will evaluate to r1 if  is  Coercible to  , and to r2 otherwise.Using coercing2 we can make more efficient implementations when  is backed up by  without exposing internals.aesonaeson aeson aeson aeson Safe-Inferred>aesonRecord tokens.aeson Array tokens.aesonNumbersWe preserve whether the number was integral, decimal or in scientific form. aesone.g. 123!aesone.g. 123.456"aesone.g. 123e456, 123e-456 or  123.456E-967#aeson Literals. null, true, false.'aeson A well-formed JSON token stream.Note: # exists to make ' have only 6 constructors. This may or may not have impact on performance. !"#$%&'()*+,-'()*+,-#$%& !" Safe-Inferredaeson*Helper type-class for constructing errors. Safe-Inferred"(sJaesonLex (and parse) strict  ByteString into ' stream.aesonStrip leading (ASCII) spaceJJ Safe-Inferred"( KaesonLex (and parse) lazy  into ' stream.aesonStrip leading (ASCII) spaceKK Safe-Inferred"(LaesonLex (and parse) strict  into ' stream.aesonStrip leading (ASCII) spaceLL Safe-Inferred )*68#2MaesonA map from JSON key type  to v.NaesonConstruct an empty map.OaesonIs the map empty?Paeson4Return the number of key-value mappings in this map.Qaeson&Construct a map with a single element.RaesonIs the key a member of the map?SaesonRemove the mapping for the specified key from this map if present.TaesonT; can be used to insert, delete, or update a value in a map.UaesonReturn the value to which the specified key is mapped, or Nothing if this map contains no mapping for the key.VaesonAssociate the specified value with the specified key in this map. If this map previously contained a mapping for the key, the old value is replaced.WaesonInsert with a function combining new and old values, taken in that order.Xaeson*Map a function over all values in the map.Yaeson*Map a function over all values in the map._aesonReduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator).`aeson experimentalportable Safe-Inferred18&.aesonSimple 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.11(c) 2011-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan  experimentalportable Safe-Inferred56;Kp>aesonException thrown by  throwDecode and variants.aesonOptions for encoding keys with  and .aesonFunction 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  opts ::  opts =  {  =  } 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 ). 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.aesonA 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.aesonA constructor will be encoded to a 2-element array where the first element is the tag of the constructor (modified by the ) and the second element the encoded contents of the constructor.aesonOptions that specify how to encode/decode your datatype to/from JSON.*Options can be set using record syntax on  with the fields below.aesonFunction applied to field labels. Handy for removing common record prefixes for example.aesonFunction applied to constructor tags which could be handy for lower-casing them for example.aesonIf & the constructors of a datatype, with all nullary constructors, will be encoded to just a string with the constructor tag. If & the encoding will always follow the .aesonIf , record fields with a 6 value will be omitted from the resulting object. If =, the resulting object will include those fields mapping to null.In  aeson-2.22 this flag is generalised to omit all values with  x = True. If , the resulting object will include those fields encoded as specified. Note that this does not affect parsing: 1 fields are optional regardless of the value of . allowOmittedFieds controls parsing behavior.aesonIf 2, missing fields of a record will be filled with  omittedField values (if they are ). If ;, all fields will required to present in the record object.aeson7Specifies how to encode constructors of a sum datatype.aesonHide 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  that uses the same non-standard serialization format as Microsoft .NET, whose  https://msdn.microsoft.com/en-us/library/system.datetime(v=vs.110).aspxSystem.DateTime 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).aesonA JSON parser. N.B. This might not fit your usual understanding of "parser". Instead you might like to think of  as a "parse result", i.e. a parser to which the input has already been applied.aesonSuccess continuation.aesonFailure continuation.aesonThe result of running a .aeson!The internal result of running a .aesonElements 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.aesonDetermines if the  is an empty . Note that:  isEmptyArray .aesonThe empty object.aesonRun a .aesonRun a .aesonRun a  with a  result type.aesonRun a  with an ( result type. If the parse fails, the ' payload will contain an error message.aesonRun a  with an ' result type. If the parse fails, the  payload will contain an error message and a json path to failed element.aeson"Annotate an error message with a  &http://goessner.net/articles/JsonPath/JSONPath error location.aeson Format a  &http://goessner.net/articles/JsonPath/JSONPath as a #, representing the root object as $.aeson Format a  &http://goessner.net/articles/JsonPath/JSONPath as a 9 which represents the path relative to some root object.aeson Create a  from a list of name/value s. If duplicate keys arise, later keys and their associated values win.aeson!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. withObject "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.10aeson If the inner Parser failed, modify the failure message using the provided function. This allows you to create more descriptive error messages. For example: parseJSON (Object o) = modifyFailure ("Parsing of the Foo value failed: " ++) (Foo <$> o .: "someField") Since 0.6.2.0aeson If the inner : failed, prepend the given string to the failure message.  s =  (s ) aeson-Throw a parser error with an additional path.aesonA handler function to handle previous errors and return to normal execution.aesonDefault encoding :  {  = id ,  = id ,  = True ,  = False ,  = True ,  =  ,  = False ,  = False ,  = False } aesonDefault   options: defaultTaggedObject =  { & = "tag" , & = "contents" } aesonDefault : defaultJSONKeyOptions =  {  =  } 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"aeson aesonaesonaesonaesonSince version 1.5.6.0 version object values are printed in lexicographic key order/toJSON $ H.fromList [("a", True), ("z", False)]4Object (fromList [("a",Bool True),("z",Bool False)])/toJSON $ H.fromList [("z", False), ("a", True)]4Object (fromList [("a",Bool True),("z",Bool False)])aesonaeson'The ordering is total, consistent with  instance. 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').  Safe-InferredLbaesonRun a  text-iso8601 parser as an aeson parser. !(c) 2011 MailRank, Inc. (c) 2013 Simon Meier BSD3%Bryan O'Sullivan  experimentalportable Safe-InferredO aeson "age" .= age)aesonOften used synonym for .aesonAn encoding of a JSON value.tag represents which kind of JSON the Encoding is encoding to, we reuse  and  as tags here.aeson*Acquire the underlying bytestring builder.aesonMake Encoding from Builder.Use with care! You have to make sure that the passed Builder is a valid JSON Encoding!aesonA variant of a > where key is already encoded including the quotes and colon.  "foo" v =  unsafePair "\"foo\":" v 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 caesonaeson double 42"42.0" double (0/0)"null" double (1/0) "\"+inf\""double (-23/0) "\"-inf\""aeson doubleText 42 "\"42.0\""doubleText (0/0) "\"NaN\""doubleText (1/0) "\"+inf\""doubleText (-23/0) "\"-inf\""aesonaeson key encodingaesonvalue encodingaeson foldrWithKey - indexed foldaeson container66" Safe-InferredW99# Safe-InferredZaesonConvert ' to .The resulting value will be in normal form if its forced. In other words, there shouldn't be thunks inside.aesontokensaeson)either token error or value and leftover.aesontokensaeson)either token error or value and leftover. $ Safe-Inferred"%&()*012<aesonConstructors need to be decoded differently depending on whether they're a record or not. This distinction is made by  ConsParseJSON.aesonList of all constructor names of an ADT, after a given conversion function. (Better inlining.)aeson, after unwrapping the 1 constructor, now carrying the data type's name.aesonLifting of the # class to binary type constructors.!Instead of manually writing your  instance,  Data.Aeson.TH provides Template Haskell functions which will derive an instance at compile time.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 ( clause to your datatype and declare a = instance for your datatype without giving a definition for . For example: '{-# LANGUAGE DeriveGeneric #-} import  GHC.Generics? data Pair a b = Pair { pairFst :: a, pairSnd :: b } deriving  instance  a =>  (Pair a) or  deriving via  (Pair a) instance  (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  with your preferred : customOptions =  {  =  %& } instance  a =>  (Pair a) where  =  customOptions aesonThis type is related to ToJSONKeyFunction. If  is used in the  instance, then ToJSONKeyValue should be used in the  ToJSONKey instance. The other three data constructors for this type all correspond to  ToJSONKeyText. Strictly speaking,  is more powerful than &, which is in turn more powerful than . For performance reasons, these exist as three options instead of one.aesonRead the docs for  ToJSONKey first. This class is a conversion in the opposite direction. If you have a newtype wrapper around , the recommended way to define instances is with generalized newtype deriving: newtype SomeId = SomeId { getSomeId :: Text } deriving (Eq,Ord,Hashable,FromJSONKey)If you have a sum of nullary constructors, you may use the generic implementation: =data Color = Red | Green | Blue deriving Generic instance  Color where  =   aeson5Strategy for parsing the key of a map-like container.aeson!This is similar in spirit to the  method of ". It makes it possible to give ) keys special treatment without using OverlappingInstances. End users should always be able to use the default implementation of this method.aesonA 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.There are various reasons a conversion could fail. For example, an % could be missing a required key, an  could be of the wrong size, or a value could be of an incompatible type. Coord  v  "x"  v  "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 ( clause to your datatype and declare a = instance for your datatype without giving a definition for . Parser a fails.Warning: If you are converting from a scientific to an unbounded type such as  you may want to add a restriction on the size of the exponent (see ) 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 , 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 withBool "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  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 must 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 . if the key is not present or if its value is , or 6 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  if the key is not present or 7 if the value cannot be converted to the desired type.This differs from  by attempting to parse  the same as any other JSON value, instead of interpreting it as .aeson7Retrieve the value associated with the given key of an %. If the key is not present and the  is  x for some x, the result will be that x.aeson7Retrieve the value associated with the given key of an -. If the key is not present or the field is null and the  is  x for some x, the result will be that x.This differs from  by attempting to parse 5 the same as any other JSON value, instead of using  when it's .aesonFunction variant of .aesonFunction variant of .aesonFunction variant of .aesonFunction variant of .aesonFunction variant of .aeson Variant of  with explicit parser function.E.g.   :: ( f,  a) ->  ->  ->  (f a)aeson Variant of  with explicit parser function.aeson Variant of  with explicit parser function.aeson Variant of  with explicit arguments.aeson Variant of  with explicit arguments.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" aesonAdd 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"aesonAdd 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.aesonaesonaesonaesonaesonaesonaesonaesonThis 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:MMZ YYYY-MM-DD HH:MM:SSZ YYYY-MM-DD HH:MM:SS.SSSZ!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 : is optional and the second two digits (also optional) are minutes.aesonaesonaesonaesonThis 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.aesonaeson%Only law abiding up to interpretationaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonNo constructors.aesonMultiple constructors.aesonSingle constructor.aesonuses , we expect that  and  instance are compatible.aesonconversion from  that always succeedsaesonconversion from  that may failaesonconversion for non-textual keysaeson)The name of the JSON type being parsed ("Object", "Array", "String", "Number",  "Boolean", or "Null").aesonThe actual value encountered.1 Safe-Inferred"%&)*02<FaesonLike . but the value is already converted to JSON ( or ), 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.TH provides Template Haskell functions which will derive an instance at compile time.The compiler cannot provide a default generic implementation for  , unlike  and .aesonaesonLifting 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 ( 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 a b = Pair { pairFst :: a, pairSnd :: b } deriving  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 =  {  =  %& } instance  a =>  (Pair a) where  =  customOptions  =  customOptions  See also .aesonaeson)key is encoded to string, produces objectaeson'key is encoded to value, produces arrayaesonTypeclass for types that can be used as the key of a map-like container (like Map or HashMap). For example, since  has a  instance and  has a , instance, we can encode a value of type Map  : Text into a  is common enough that a special combinator is provided for it. The above instance can be rewritten as: instance ToJSONKey Color where toJSONKey = toJSONKeyText (Text.pack . show)The performance of the above instance can be improved by not using / as an intermediate step when converting to . One option for improving performance would be to use template haskell machinery from the  text-show2 package. However, even with the approach, the  (a wrapper around a bytestring builder) is generated by encoding the  to a  ByteString, an intermediate step that could be avoided. The fastest possible implementation would be: -- 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 OverlappingInstances. End users should always be able to use the default implementation of this method.aeson8An optional key-value pair for envoding to a JSON objectaeson,A key-value pair for encoding a JSON object.aesonaeson%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  literals. {-# LANGUAGE OverloadedStrings #-} data Coord = Coord { x :: Double, y :: Double } instance  Coord where  (Coord x y) =  ["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 ( clause to your datatype and declare a . instance. If you require nothing other than , 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  instance  Coord where  =   or more conveniently using the https://downloads.haskell.org/ghc/9.2.3/docs/html/users_guide/exts/deriving_via.htmlDerivingVia extension  deriving via  Coord instance  Coord If on the other hand you wish to customize the generic decoding, you have to implement both methods: customOptions =  {  =  %& } instance  Coord where  =  customOptions  =  customOptions /Previous versions of this library only had the  method. Adding  had two reasons: ; is more efficient for the common case that the output of  is directly serialized to a  ByteString. Further, expressing either method in terms of the other would be non-optimal.The choice of defaults allows a smooth transition for existing users: Existing instances that do not define  still compile and have the correct semantics. This is ensured by making the default implementation of  use . 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 Coord 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.The 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 must provide an implementation for this method. The easiest way to do so is by having your types implement  using the  DeriveGeneric extension, and then have GHC generate a method body as follows.  instance  Coord where  =   aesonDefines when it is acceptable to omit a field of this type from a record. Used by (). operator, and Generics and TH deriving with  = True.aesonA " value either stores nothing (for ) or it stores the three function arguments that encode occurrences of the type parameter (for ).aesonClass 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 .aeson?A configurable generic JSON creator. This function applied to  is used as the default for " when the type is an instance of .aeson?A configurable generic JSON encoder. This function applied to  is used as the default for " when the type is an instance of .aeson?A configurable generic JSON encoder. This function applied to  is used as the default for " when the type is an instance of .aeson!Helper for creating textual keys.  instance  MyKey where  =  myKeyToText where myKeyToText = Text.pack . show -- or showt from text-show aesonaesonTODO: 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 23 F where 24 p _ v = F <$> 24 p (25 p) v aesonHelper function to use with , see .aeson!Encode something t a JSON string.aesonaesonaesonaesonaesonaesonaesonEncoded as numberaesonaesonaesonaesonaesonConstructs a singleton M*. For calling functions that demand an = for constructing objects. To be used in conjunction with . Prefer to use  where possible.aesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonaesonindexaesonlength8886(c) 2011-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan  experimentalportable Safe-Inferred )*/܄(c) 2011-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan  experimentalportable Safe-InferredNaeson Encode a  as a JSON array. (c) 2012-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan  experimentalportable Safe-Inferred"aesonEncode 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 78, it is more efficient to use encode (lazy ByteString) or  fromEncoding .  (ByteString.Builder) instead.Note: Uses  Safe-Inferred aeson3Efficiently deserialize a JSON value from a strict 985. If this fails due to incomplete or invalid input,  is returned.aesonLike 2 but returns an error message when decoding fails.aesonLike  but throws an  when decoding fails.aeson1Efficiently deserialize a JSON value from a lazy 785. If this fails due to incomplete or invalid input,  is returned.aesonLike 2 but returns an error message when decoding fails.aesonLike  but throws an  when decoding fails. is in aeson0 since 2.1.2.0, but this variant is added later.aeson3Efficiently deserialize a JSON value from a strict 985. If this fails due to incomplete or invalid input,  is returned.aesonLike 2 but returns an error message when decoding fails.aesonLike  but throws an  when decoding fails.   (c) 2011-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan  experimentalportable Safe-Inferred 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.aesonEfficiently deserialize a JSON value from a file. If this fails due to incomplete or invalid input,  is returned.The 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 json for details.aeson1Efficiently deserialize a JSON value from a lazy 5. If this fails due to incomplete or invalid input,  is returned.Since 2.2.0.0 an alias for .aeson3Efficiently deserialize a JSON value from a strict 5. If this fails due to incomplete or invalid input,  is returned.Since 2.2.0.0 an alias for .aesonEfficiently deserialize a JSON value from a file. If this fails due to incomplete or invalid input,  is returned.Since 2.2.0.0 an alias for .aesonLike 2 but returns an error message when decoding fails.aesonLike 2 but returns an error message when decoding fails.Since 2.2.0.0 an alias for .aesonLike 2 but returns an error message when decoding fails.Since 2.2.0.0 an alias for .aesonLike 2 but returns an error message when decoding fails.Since 2.2.0.0 an alias for .aesonLike  but throws an  when decoding fails.Since 2.2.0.0 an alias for .aesonLike  but throws an  when decoding fails.Since 2.2.0.0 an alias for .  Safe-Inferred^aeson?Encode to JSON according to RFC 8785 canonicalization scheme. -https://datatracker.ietf.org/doc/html/rfc8785 uses  to produce intermediate , as 3 may (and most likely) produces non-canonical JSON.Note: %decode (encodeCanonical v) === Just v for all  v :: Value, i.e.  doesn't lose any information. However, the example in RFC8785 loses; information as the intermediate number representation is , also current toJSON :: Double -> Value4 sometimes produces too precise values. For exampletoJSON (1e23 :: Double)Number 9.999999999999999e22 also behaves the same:1e23 :: Double9.999999999999999e22Note: RFC8785 is not the same scheme as used in  2https://hackage.haskell.org/package/canonical-jsoncanonical-json package (https:/wiki.laptop.org*go/Canonical_JSON). That scheme produces invalid JSON (e.g. control characters encoded as is, not escaped) and cannot encode non-integral numbers.  Safe-Inferred|aeson6Converts a string representation of a JSON value into  at compile-time. {-# LANGUAGE QuasiQuotes #-} import Data.Aeson (Value) import Data.Aeson.QQ.Simple joe :: / joe = [aesonQQ|{ "name": "Joe", "age": 12 }|] (c) 2011-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3 experimentalportable Safe-Inferred'-aesonWhether 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.aesonA representation of the arity of the ToJSON/FromJSON typeclass being derived.aesonGenerates both  and  instance declarations for the given data type or data family instance constructor.This is a convenience function which is equivalent to calling both  and .aesonGenerates both  and  instance declarations for the given data type or data family instance constructor.This is a convenience function which is equivalent to calling both  and .aesonGenerates both  and  instance declarations for the given data type or data family instance constructor.This is a convenience function which is equivalent to calling both  and .aeson Generates a  instance declaration for the given data type or data family instance constructor.aeson Generates a  instance declaration for the given data type or data family instance constructor.aeson Generates a  instance declaration for the given data type or data family instance constructor.aesonGenerates a lambda expression which encodes the given data type or data family instance constructor as a .aesonGenerates a lambda expression which encodes the given data type or data family instance constructor as a  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  by using the given encoding functions on occurrences of the last two type parameters.aesonGenerates 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  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 .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.aesonGenerates 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  instance declaration for the given data type or data family instance constructor.aeson Generates a  instance declaration for the given data type or data family instance constructor.aeson Generates a  instance declaration for 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.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 . Generates code to parse the JSON encoding of a number of constructors. All constructors must be from the same type.aesonGenerates code to parse the JSON encoding of a single constructor.aesonGenerates 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.See 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 kind is of the form k_0 -> k_1 -> ... -> k_(n-1), where k0, k1, ..., and k_(n-1) can be * or kind variables.aesonIf a Type is a SigT, returns its kind signature. Otherwise, return *.aesonExtract Just the Name from a type variable. If the argument Type is not a type variable, return Nothing.aesonExtract 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?aesonDetect if a Name in a list of provided Names occurs as an argument to some type family. This makes an effort to exclude  oversaturated 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).aesonAre all of the items in a list (which have an ordering) distinct?This uses Set (as opposed to nub) for better asymptotic time complexity.aeson9Does the given type mention any of the Names in the list?aesonDoes an instance predicate mention any of the Names in the list?aesonSplit an applied type into its individual components. For example, this: Either Int Char would split to this: [Either, Int, Char] aesonSplit 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?@ABCDEFGHIJKLMNOPQRSTUVWX0YZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~(-/.0/-;                           (                                                        #$$$$$3$4$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$5$$$$$$$$$$$$$$$$$$$$$$$$111111111111111111111111111111111111111111111111,166                <)(88 !!!!!!!!!!!!!!!!!!!!!!!!!########$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$1111111111111111111111111111111111111111111111$aeson-2.2.1.0-GU03yYEaVbfFZQFiWWRWc5Data.Aeson.DecodingData.Aeson.KeyData.Aeson.Decoding.TokensData.Aeson.Decoding.Text#Data.Aeson.Decoding.ByteString.LazyData.Aeson.Decoding.ByteStringData.Aeson.KeyMapData.Aeson.TypesData.Aeson.Encoding.Internal Data.AesonData.Aeson.TextData.Aeson.RFC8785Data.Aeson.QQ.Simple Data.Aeson.THData.Aeson.Internal.ByteStringData.Aeson.Internal.FunctionsData.Aeson.Internal.PreludeData.Aeson.Internal.ScientificData.Aeson.Internal.THData.Aeson.Internal.TextData.Aeson.Internal.Unescape$Data.Aeson.Internal.UnescapeFromTextData.Aeson.Internal.Word16Data.Aeson.Internal.Word8Data.Aeson.Decoding.InternalData.Aeson.Types.GenericData.Aeson.Types.InternalgenericFromJSONKeygenericToJSONKey omitFieldFromJSONData.Aeson.Parser.TimeData.Aeson.Encoding.BuilderData.Aeson.EncodingData.Aeson.Decoding.ConversionData.Aeson.Types.FromJSON Data.ChartoUpperControl.Applicativeempty Control.MonadmzeroData.Aeson.ToJSON listEncodingObjectStringArrayNumberData.Aeson.Types.ToJSONData.Aeson.FromJSON FromJSON1 liftParseJSON listParserData.Aeson.Types.ClassL ByteStringB unescapeTextKey fromStringtoStringfromTexttoTextcoercionToText toShortText fromShortText $fFunctionKey$fCoArbitraryKey$fArbitraryKey$fLiftBoxedRepKey $fMonoidKey$fSemigroupKey $fNFDataKey $fHashableKey $fIsStringKey $fShowKey $fReadKey$fEqKey$fOrdKey $fDataKeyTkRecordTkPair TkRecordEnd TkRecordErrTkArrayTkItem TkArrayEnd TkArrayErr NumInteger NumDecimal NumScientificLitLitNullLitTrueLitFalseTokensTkLitTkTextTkNumber TkArrayOpen TkRecordOpenTkErr$fBitraversableTkRecord$fBitraversableTkArray$fBitraversableTokens$fBifoldableTkRecord$fBifoldableTkArray$fBifoldableTokens$fBifunctorTkRecord$fBifunctorTkArray$fBifunctorTokens$fTraversableTkRecord$fTraversableTkArray$fTraversableTokens$fFoldableTkRecord$fFoldableTkArray$fFoldableTokens$fFunctorTkRecord$fFunctorTkArray$fFunctorTokens $fEqTkRecord$fShowTkRecord $fEqTokens $fShowTokens $fEqTkArray $fShowTkArray $fEqNumber $fShowNumber$fEqLit $fShowLit textToTokens lbsToTokens bsToTokensKeyMapnullsize singletonmemberdeletealterFlookupinsert insertWithmap mapWithKeyfoldMapWithKeyfoldrfoldr'foldlfoldl' foldrWithKeytraversetraverseWithKey fromListWithfromListtoListelems toAscList differenceunion unionWith unionWithKey intersectionintersectionWithintersectionWithKeykeys toHashMap fromHashMaptoMapfromMapcoercionToHashMap coercionToMap mapKeyValfilter filterWithKeymapMaybemapMaybeWithKey!? alignWith alignWithKey toHashMapTextfromHashMapText toMapText fromMapText$fFunctionKeyMap$fCoArbitraryKeyMap$fArbitraryKeyMap$fArbitrary1KeyMap$fWitherableWithIndexKeyKeyMap$fFilterableWithIndexKeyKeyMap$fWitherableKeyMap$fFilterableKeyMap $fAlignKeyMap$fSemialignWithIndexKeyKeyMap$fSemialignKeyMap$fZipWithIndexKeyKeyMap $fZipKeyMap$fTraversableWithIndexKeyKeyMap$fFoldableWithIndexKeyKeyMap$fFunctorWithIndexKeyKeyMap$fNFDataKeyMap$fHashableKeyMap$fLiftBoxedRepKeyMap$fIsListKeyMap$fMonoidKeyMap$fSemigroupKeyMap$fTraversableKeyMap$fFoldableKeyMap $fShowKeyMap $fReadKeyMap $fEqKeyMap $fOrdKeyMap $fDataKeyMap$fFunctorKeyMapOneZeroAesonExceptionJSONKeyOptions keyModifier SumEncoding TaggedObject UntaggedValueObjectWithSingleField TwoElemArray tagFieldNamecontentsFieldNameOptionsfieldLabelModifierconstructorTagModifierallNullaryToStringTagomitNothingFieldsallowOmittedFields sumEncodingunwrapUnaryRecordstagSingleConstructorsrejectUnknownFieldsPair DotNetTimefromDotNetTimeValueBoolNullParserResultErrorSuccessIResultIErrorISuccessJSONPathJSONPathElementIndex parseFail emptyArray emptyObjectparseiparse parseMaybe parseEither iparseEither formatError formatPathformatRelativePathobject modifyFailureprependFailureparserThrowErrorparserCatchErrordefaultOptionsdefaultTaggedObjectdefaultJSONKeyOptionscamelTocamelTo2InArraySeriesEmptyEncoding Encoding' fromEncodingunsafeToEncodingencodingToLazyByteString retagEncodingpairpairStrpair' unsafePairSBS nullEncoding emptyArray_ emptyObject_ wrapArray wrapObjectnull_boolpairslistdict>*<econcat><tuplekeytextlazyText shortTextstringcommacolon openBracket closeBracket openCurly closeCurlyint8int16int32int64intword8word16word32word64wordintegerfloatdouble scientificint8Text int16Text int32Text int64TextintText word8Text word16Text word32Text word64TextwordText integerText floatText doubleTextscientificTextdaymonthquarter localTimeutcTime timeOfDay zonedTimevalue$fIsStringEncoding'$fOrdEncoding' $fEqEncoding'$fShowEncoding'$fMonoidSeries$fSemigroupSeries toEitherValue FromJSON2liftParseJSON2liftParseJSONList2liftOmittedField2liftParseJSONListliftOmittedField GFromJSONKeyFromJSONKeyFunctionFromJSONKeyCoerceFromJSONKeyTextFromJSONKeyTextParserFromJSONKeyValue FromJSONKey fromJSONKeyfromJSONKeyList parseJSON parseJSONList omittedFieldFromArgs GFromJSONparseIndexedJSONgenericParseJSONgenericLiftParseJSONfromJSONKeyCoercecoerceFromJSONKeyFunctionmapFromJSONKeyFunction typeMismatch unexpected parseJSON1 omittedField1 parseJSON2 omittedField2 withObjectwithText withArraywithScientificwithBoolwithEmbeddedJSONfromJSON ifromJSON.:.:?.:!.:?=.:!= parseFieldparseFieldMaybeparseFieldMaybe'parseFieldOmitparseFieldOmit'explicitParseFieldexplicitParseFieldMaybeexplicitParseFieldMaybe'explicitParseFieldOmitexplicitParseFieldOmit'.!=ToJSON2 liftToJSON2liftToJSONList2liftToEncoding2liftToEncodingList2liftOmitField2ToJSON1 liftToJSONliftToJSONListliftToEncodingliftToEncodingList liftOmitField GToJSONKeyToJSONKeyFunction ToJSONKeyTextToJSONKeyValue ToJSONKey toJSONKey toJSONKeyList KeyValueOmit.?=explicitToFieldOmitKeyValue.=explicitToFieldToJSONtoJSON toEncoding toJSONListtoEncodingListToArgsGToJSON' genericToJSONgenericLiftToJSONgenericToEncodinggenericLiftToEncoding toJSONKeyText toJSONKeyKeycontramapToJSONKeyFunctiontoJSON1 toEncoding1 omitField1toJSON2 toEncoding2 omitField2 listValue GToEncodingGToJSONfoldableencodeToLazyTextencodeToTextBuilder decodeStricteitherDecodeStrictthrowDecodeStrictdecode eitherDecode throwDecodedecodeStrictTexteitherDecodeStrictTextthrowDecodeStrictTextencode encodeFiledecodeFileStrictdecode' decodeStrict'decodeFileStrict'eitherDecodeFileStrict eitherDecode'eitherDecodeStrict'eitherDecodeFileStrict' throwDecode'throwDecodeStrict'encodeCanonicalaesonQQ deriveJSON deriveJSON1 deriveJSON2 deriveToJSON deriveToJSON1 deriveToJSON2mkToJSON mkLiftToJSON mkLiftToJSON2 mkToEncodingmkLiftToEncodingmkLiftToEncoding2deriveFromJSONderiveFromJSON1deriveFromJSON2 mkParseJSONmkLiftParseJSONmkLiftParseJSON2$fEqStarKindStatus $fEnumArity $fEqArity $fOrdArity $fEqFunArgmkBSwithBSliftSBS4unordered-containers-0.2.19.1-B1FvfMmwkyn8JRtlr9YJUIData.HashMap.InternalHashMap mapKeyValOcontainers-0.6.5.1Data.Map.InternalMapmapKeymapKeyOghc-primGHC.Primcoercebase Data.DataDataData.Typeable.InternalTypeableControl.Monad.FixMonadFixmfix Data.StringIsStringGHC.BaseliftA2 Data.Foldable GHC.GenericsGeneric Semigroupstimes<>sconcatGHC.IntInt8Int16Int32Int64 ghc-bignumGHC.Num.NaturalNaturalGHC.WordWord8Word16Word32Word64 GHC.Types Coercible Data.VoidVoidabsurdunlessData.Functor.ConstConstgetConst Data.ProxyProxy Data.Maybe fromMaybe catMaybes Data.Functionfix Data.Functorvoid$> Alternativesomemany<|>whenliftM2(generically-0.1.1-94N4gH3EgVGCxFZFEw34Z0GHC.Generics.Generically Generically Generically1 text-2.0.2-7m9cX8KC0uFFaB64QvE9WData.Text.InternalText)scientific-0.3.7.0-2uhPQvbHyHgC0sQIU7ydM4Data.Scientific Scientific time-1.11.1.1 Data.Time.Clock.Internal.UTCTimeUTCTime&vector-0.13.0.0-JKrBPPZBIK2JBM2KZEUb7Z Data.VectorVectorscanScientificautoletEletrecEunsafeDecodeASCIIunescapeFromTextW8_EW8_tW8_nW8_fW8_eW8_9W8_0W8_MINUSW8_PLUSW8_CLOSE_SQUAREW8_CLOSE_CURLYW8_OPEN_SQUARE W8_OPEN_CURLYW8_COLONW8_DOUBLE_QUOTEW8_DOTW8_COMMA W8_BACKSLASHW8_TABW8_CRW8_NLW8_SPACEAsErrortkErr negateNumber skipSpace*bytestring-0.11.5.2-LxsikvUpeUiConIrauPPnxData.ByteString.Lazy.InternalData.ByteString.Internal.Type:* ProductSize productSizeAndFalseTrueTagged2 unTagged2 AllNullaryIsRecord GHC.UnicodetoLower GHC.MaybeNothingMaybeJustFailure isEmptyArray Data.EitherEitherLeft++id$fMonadFixParser$fLiftBoxedRepValue$fCoArbitraryValue$fArbitraryValue $fShowValue$fFunctionValue $fOrdValue GHC.ClassesEqrun'text-iso8601-0.1-EhsOPwEqxWd13dzHif9pOSData.Time.FromTextparseZonedTime parseUTCTimeparseLocalTimeparseTimeOfDayparseQuarterOfYear parseQuarter parseMonthparseDay TimeOfDay64encodeToBuilder Data.ByteString.Builder.InternalBuilderarrayunquotedquote encodeYearascii2ascii4ascii5 toResultValueunResultbsSpacelbsSpace textSpace ltextSpace ConsFromJSONConstructorNames GFromJSON'D1Generic1GHC.ReadreadListReadControl.Monad.Failfail<$><*> gParseJSON'hashable-1.4.3.0-B3jJEaFbXEQIpclO4WmnNCData.Hashable.ClassHashablefmaptypeOfprependContextGHC.Num.IntegerIntegerwithBoundedScientificwithScientific'withBoundedScientific'withBoundedScientific_ contextType contextTag contextConsshowCons failWithCTagsconstructorTags$fFromJSONThese$fFromJSONMaybe$fFromJSONEither$fFromJSONPair$fFromJSONThese0 $fFromJSONURI$fFromJSONDown$fFromJSONDiffTime$fFromJSONNominalDiffTime$fFromJSONZonedTime$fFromJSONKeyMap$fFromJSONDNonEmpty$fFromJSONShortText$fFromJSONInteger$fFromJSONFixed$fFromJSONGenerically$fFunctorFromJSONKeyFunction$fFromJSONKeyURI$fFromJSONKeySolo$fFromJSONKeyShortText$fFromJSONKeyVoid$fFromJSONThese1$fFromJSON1These1$fFromJSON1These$fFromJSON1Maybe$fFromJSON1Either$fFromJSON1Pair$fFromJSON1These0 $fFromJSONNu $fFromJSONMu $fFromJSONFix$fFromJSON1Down$fFromJSON1KeyMap$fFromJSONSolo$fFromJSON1Solo$fFromJSON1DNonEmpty$fFromJSON1Generically1$fFromJSON2These$fFromJSON2Either$fFromJSON2Pair$fFromJSON2These0$fGFromJSON'arityV1$fGFromJSON'arity:+:$fGFromJSON'arityM1Ord NoFromArgs From1ArgsparseOptionalFieldWith KeyValuePair FromPairs GetConNameCharIntGHC.ShowShowgToJSONtoJSONKeyTextEncstringEncoding $fToJSONMaybe$fToJSONEither $fToJSONPair $fToJSONThese $fToJSONURI $fToJSONDown$fToJSONSystemTime$fToJSONDNonEmpty$fToJSONShortText$fToJSONGenerically$fToJSONThese0$fKeyValueValueKeyMapmconcat$fToJSONKeyURI$fToJSONKeySolo$fToJSONKeyShortText$fToJSONKeyVoid$fToJSONThese1$fToJSON1These$fToJSON1Maybe$fToJSON1Either $fToJSON1Pair$fToJSON1These0 $fToJSONNu $fToJSONMu $fToJSONFix $fToJSON1Down $fToJSONSolo $fToJSON1Solo$fToJSON1DNonEmpty$fToJSON1Generically1$fToJSON2These$fToJSON2Either $fToJSON2Pair$fToJSON2These0$fToJSON1These1 writeProduct fromPairsNoToArgsTo1ArgsFoldableData.Text.Internal.BuilderDoubleshowStarKindStatus JSONClass ToJSONFunJSONFun DirectionArity consToValueconStrconTxt conString isNullaryopaqueSumToValue sumToValuerecordSumToValue argsToValueobjectEmconcatEpairE consFromJSON parseArgs parseProductderiveJSONBothderiveJSONClassderiveConstraint hasKindStarhasKindVarChaintyKindvarTToNameMaybe varTToName applyTyConisTyVarisInTypeFamilyAppunSigT allDistinct mentionsNamepredMentionsName unapplyTy uncurryTy uncurryKind conNameExp fieldLabel valueConName canEtaReducederivingKindErroretaReductionErrordatatypeContextErroroutOfPlaceTyVarErrorexistentialContextErrorcanRealizeKindStarstarKindStatusToNametemplate-haskellLanguage.Haskell.TH.SyntaxNamecatKindVarNamesderiveToJSONCommonmkToJSONCommonmkToEncodingCommonderiveFromJSONCommonmkParseJSONCommonCon mkFunCommonbuildTypeInstance<^><%>