O      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                     D(c) 2011-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableNone!"0IOT)7Specifies how to encode constructors of a sum datatype.9A 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.Constructor names won't be encoded. Instead only the contents of the constructor will be encoded as if the type had 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:8 Nullary constructors are encoded as the string (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 mailformed JSON, only an error for the last constructor will be reported.rA 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.|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.EOptions that specify how to encode/decode your datatype to/from JSON. YFunction applied to field labels. Handy for removing common record prefixes for example. ]Function applied to constructor tags which could be handy for lower-casing them for example. If & the constructors of a datatype, with allW nullary constructors, will be encoded to just a string with the constructor tag. If & the encoding will always follow the  . If  record fields with a 6 value will be omitted from the resulting object. If < the resulting object will include those fields mapping to null. 7Specifies how to encode constructors of a sum datatype.RHide the field name when a record constructor has only one field, like a newtype.A key/value pair for an .A newtype wrapper for Q 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.Acquire the underlying value.,A JSON value represented as a Haskell value.A JSON "array" (sequence). A JSON "object" (key/value map).A JSON parser.Success continuation.Failure continuation.The result of running a . !The internal result of running a .$CElements of a JSON path used to describe the location of an error.%9JSON path element of a key into an object, "object.key".&=JSON path element of an index into an array, "array[index]".'The empty array.Determines if the  is an empty . Note that:  isEmptyArray '.(The empty object.)Run a .*Run a .+Run a  with a  result type.,Run a  with an ( result type. If the parse fails, the ' payload will contain an error message.-"Annotate an error message with a  &http://goessner.net/articles/JsonPath/JSONPath error location.. Create a  from a list of name/value Ks. If duplicate keys arise, earlier keys and their associated values win./!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.100 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.01Default encoding :  {   = id ,   = id ,   = True ,   = False ,   = 2 ,  = False } 2Default   options: defaultTaggedObject =  { & = "tag" , & = "contents" } 3Converts 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"4Better version of 3 . Example where it works better: ]camelTo '_' 'CamelAPICase' == "camel_apicase" camelTo2 '_' 'CamelAPICase' == "camel_api_case"`  !"#$%& '()*+,-./01234!"#$%&'()*+,-./0123456789:;<=>?@ABCD6  !"#$%&'()*+,-./01234C  !"#$%& '()*+,-./01234!"#$%&'()*+,-./0123456789:;<=>?@ABCD n(c) 2012-2016 Bryan O'Sullivan (c) 2011, 2012 Bas Van Dijk (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableSafe ,9;<=?DQRT5A type-level indicator that ToJSON1 or  FromJSON1 is being derived generically.6A type-level indicator that ToJSON or FromJSON is being derived generically.#EF56GHIJKLMNOPQRSTUVWXYZ[\]^_`abcde EF56GHIJKLMNOEF56GHIJKLMNOPQRSTUVWXYZ[\]^_`abcde None Bfghhfgh NonehD(c) 2011-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableNoneB 7Parse a top-level 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 9r. In aeson 0.8 and earlier, it parsed only object or array types, in conformance with the now-obsolete RFC 4627.8Parse a top-level JSON value.This is a strict version of 7 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 :r. In aeson 0.8 and earlier, it parsed only object or array types, in conformance with the now-obsolete RFC 4627.9*Parse any JSON value. You should usually 7h in preference to this function, as this function relaxes the object-or-array requirement of RFC 4627.In particular, be careful in using this function if you think your code might interoperate with Javascript. A nave Javascript library that parses JSON data using eval is vulnerable to attack unless the encoded data represents an object or an array. JSON implementations in other languages conform to that same restriction to preserve interoperability and security.:Strict version of 9 . See also 8.;Parse a quoted JSON string.i'Parse a string without a leading quote.j[Parse a top-level JSON value followed by optional whitespace and end-of-input. See also: 7.k[Parse a top-level JSON value followed by optional whitespace and end-of-input. See also: 8.lZThe only valid whitespace in a JSON document is space, newline, carriage return, and tab.mnop78qrstuv9:;i<=>?jklwx 789:;<=>?jkmnop78qrstuv9:;i<=>?jklwxD(c) 2012-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableNone 789:;<=>? 79;8:<=>?(c) 2015-2016 Bryan O'SullivanBSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableNone@<Like TimeOfDay, but using a fixed-width integer for seconds.@ABCDE@ABCDE@ACBDE@ABCDE(c) 2015-2016 Bryan O'SullivanBSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableNoneT y,Run an attoparsec parser as an aeson parser.zParse a date of the form [+,-]YYYY-MM-DD.{4Parse a two-digit integer (e.g. day of month, hour).|Parse a time of the form HH:MM[:SS[.SSS]].}GParse a count of seconds, with the integer part being two digits long.~Parse a time zone, and return F if the offset from UTC is zero. (This makes some speedups possible.)#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. Behaves as 5, but converts any time zone offset into a UTC time.5Parse 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. yz{|}~yz|~ yz{|}~D(c) 2011-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableSafe Transform a  into a  while transforming the keys.#Transform the keys and values of a .Transform the keys of a .None!"#$%&+,69:;<=DQRT.FLifting of the T# class to binary type constructors.!Instead of manually writing your F instance,  Data.Aeson.THT provides Template Haskell functions which will derive an instance at compile time.ILifting of the T" class to unary type constructors.!Instead of manually writing your I9 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 will probably be more efficient than the following two options:?The compiler can provide a default generic implementation for J. To use the second, simply add a  deriving ( clause to your datatype and declare a I= instance for your datatype without giving a definition for J. For example: '{-# LANGUAGE DeriveGeneric #-} import  GHC.Generics? data Pair a b = Pair { pairFst :: a, pairSnd :: b } deriving , instance FromJSON a => FromJSON1 (Pair a) If DefaultSignatures~ 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 : Dinstance FromJSON a => FromJSON1 (Pair a) where liftParseJSON = ] 1 LThis type is related to ToJSONKeyFunction. If P is used in the Q instance, then ToJSONKeyValue should be used in the  ToJSONKeyS instance. The other three data constructors for this type all correspond to  ToJSONKeyText. Strictly speaking, O is more powerful than N&, which is in turn more powerful than MJ. For performance reasons, these exist as three options instead of one.Muses  ( in older GHCs)Nconversion from  that always succeedsOconversion from  that may failPconversion for non-textual keysWith GHC 7.8+ we carry around   at dictionary, to give us an assurance that the program will not segfault. Unfortunately we cannot enforce that the  instances or the  instances for  and a agree.7At the moment this type is intentionally not exported. L. can be inspected, but cannot be constructed.QRead the docs for  ToJSONKeyf first. This class is a conversion in the opposite direction. If you have a newtype wrapper around R, the recommended way to define instances is with generalized newtype deriving: Vnewtype SomeId = SomeId { getSomeId :: Text } deriving (Eq,Ord,Hashable,FromJSONKey)R5Strategy for parsing the key of a map-like container.S!This is similar in spirit to the  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.TIA 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:empty and mzero& work, but are terse and uninformative yields a custom error messageab produces an informative message for cases when the value encountered is not of the expected type#An example type and instance using a: -- Allow ourselves to write  literals. {-# LANGUAGE OverloadedStrings #-} data Coord = Coord { x :: Double, y :: Double } instance FromJSON Coord where parseJSON ( v) = Coord  v m "x"  v m$ "y" -- We do not expect a non-! value here. -- We could use mzero to fail, but aP -- gives a much more informative error message. parseJSON invalid = a "Coord" invalid ^For this common case of only being concerned with a single type of JSON value, the functions  withObject,  withNumberd, etc. are provided. Their use is to be preferred when possible, since they are more terse. Using  withObject^, we can rewrite the above instance (assuming the same language extension and data type) as: Vinstance FromJSON Coord where parseJSON = withObject "Coord" $ v -> Coord  v m "x"  v m "y" !Instead of manually writing your T9 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 will probably be more efficient than the following two options:?The compiler can provide a default generic implementation for U. To use the second, simply add a  deriving ( clause to your datatype and declare a T= instance for your datatype without giving a definition for U.<For example, the previous example can be simplified to just: '{-# LANGUAGE DeriveGeneric #-} import  GHC.Generics; data Coord = Coord { x :: Double, y :: Double } deriving  instance FromJSON Coord If DefaultSignatures~ 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 : .instance FromJSON Coord where parseJSON = \ 1 WA W" value either stores nothing (for T_) or it stores the two function arguments that decode occurrences of the type parameter (for I).ZFClass of generic representation types that can be converted from JSON.[This method (applied to 14) is used as the default generic implementation of U (if the arity is 6) or J (if the arity is 5).\?A configurable generic JSON decoder. This function applied to 1 is used as the default for U" when the type is an instance of .]?A configurable generic JSON decoder. This function applied to 1 is used as the default for J" when the type is an instance of .^ Construct L for types coercible from '. This conversion is still unsafe, as  and  instances of a should be compatible with n i.e. hash values should be equal for wrapped values as well. This property will always be maintained if the  and L instances are derived with generalized newtype deriving. compatible with 6 i.e. hash values be equal for wrapped values as well./On pre GHC 7.8 this is unconstrainted function._Semantically the same as 0coerceFromJSONKeyFunction = fmap coerce = coerce. See note on ^.`Same as $. Provided for the consistency with ToJSONKeyFunction.a@Fail parsing due to a type mismatch, with a descriptive message.Example usage: +instance FromJSON Coord where parseJSON (@ v) = {- type matches, life is good -} parseJSON wat = a "Coord" wat bLift the standard U' function through the type constructor.cLift the standard U' function through the type constructor.dHelper function to use with J. See .ewithObject expected f value applies f to the  when value is an Object and fails using a expected otherwise.fwithText expected f value applies f to the  when value is a String and fails using a expected otherwise.gwithArray expected f value applies f to the  when value is an Array and fails using a expected otherwise.hwithNumber expected f value applies f to the  when value is a . and fails using a expected otherwise.iwithScientific expected f value applies f to the  number when value is a . and fails using a expected otherwise.jwithBool expected f value applies f to the  when value is a Bool and fails using a expected otherwise.k=Convert a value from JSON, failing if the types do not match.l=Convert a value from JSON, failing if the types do not match.m7Retrieve 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 n instead.n7Retrieve the value associated with the given key of an . The result is . 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 m instead.o7Retrieve the value associated with the given key of an . The result is  if the key is not present or empty7 if the value cannot be converted to the desired type.This differs from n by attempting to parse B the same as any other JSON value, instead of interpreting it as .pFunction variant of m.qFunction variant of n.rFunction variant of o.s Variant of m with explicit parser function.E.g. s b :: (I f, T a) ->  ->  ->  (f a)t Variant of n with explicit parser function.u Variant of o with explicit parser function.v#Helper for use in combination with n< 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 m instead.Example usage:  v1 <- o n1 "opt_field_with_dfl" .!= "default_val" v2 <- o m "mandatory_field" v3 <- o n "opt_field2" WARNING: Only parse lengths of time from trusted input since an attacker could easily fill up the memory of the target system by specifying a scientific number with a big exponent like  1e1000000000.WARNING: Only parse Integers from trusted input since an attacker could easily fill up the memory of the target system by specifying a scientific number with a big exponent like  1e1000000000.WARNING: Only parse fixed-precision numbers from trusted input since an attacker could easily fill up the memory of the target system by specifying a scientific number with a big exponent like  1e1000000000.%Only law abiding up to interpretation'FGHIJKLMNOPQRSTUVWXYZ[\]^_`a-The name of the type you are trying to parse.The actual value encountered.bcdefghijklmnopqrstuv      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~2FGHIJKLPMNOQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuv FGHIJJKLMNOPQRRSSTUUVWXYZ[\]^_`abcdefghijklmnopqrstuv      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~(c) 2015-2016 Bryan O'SullivanBSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableNone !"#$%&*-/l !"$%&#/-l*O(c) 2011 MailRank, Inc. (c) 2013 Simon Meier <iridcode@gmail.com>BSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableNone Encode 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.Encode a JSON null.Encode a JSON boolean.Encode a JSON array.Encode a JSON string./Encode a JSON string, without enclosing quotes. Add quotes surrounding a builderEncode a JSON string.Encode a JSON number.None0OT w"Type tag for tuples contents, see .x[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 xb. 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){Often used synonnym for |.|An encoding of a JSON value.tagF represents which kind of JSON the Encoding is encoding to, we reuse  and  as tags here.~*Acquire the underlying bytestring builder.Make Encoding from Builder.WUse with care! You have to make sure that the passed Builder is a valid JSON Encoding!8Encode a series of key/value pairs, separated by commas.Encode as JSON objectSee .Encode as a tuple._@ toEncoding (X a b c) = tuple $ toEncoding a >*< toEncoding b >*< toEncoding cMwxyz{|}~ key encodingvalue encoding foldrWithKey - indexed fold containerGwxyz{|}~G|}~{xyzwIwxyz{|}~66None5x{|~6{|~~xNone!"#%&+,69:;<=DQRT2Get the name of the constructor of a sum datatype.Lifting 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 .Lifting 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 will probably be more efficient than the following two options:?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 = Pair { pairFst :: a, pairSnd :: b } deriving ( instance ToJSON a => ToJSON1 (Pair a) If DefaultSignatures~ 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 : Ainstance ToJSON a => ToJSON1 (Pair a) where liftToJSON =  1 liftToEncoding =  1 )key is encoded to string, produces object'key is encoded to value, produces arrayQTypeclass 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  :<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 , 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 E. The recommended approach is to use generalized newtype deriving: Pnewtype 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 E that does not require any escape sequences. So, in this example,  will be used instead of  . The $ 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 ^. 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  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.8Strategy for rendering the key for a map-like container.!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.,A key-value pair for encoding a JSON object.%A type that can be converted to JSON.An example type and instance: -- Allow ourselves to write  literals. {-# LANGUAGE OverloadedStrings #-} data Coord = Coord { x :: Double, y :: Double } instance ToJSON Coord where toJSON (Coord x y) = . ["x"  x, "y"  y] toEncoding (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 will probably be more efficient than the following two options:?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 .PFor example, the previous example can be simplified to a more minimal instance: '{-# LANGUAGE DeriveGeneric #-} import  GHC.Generics; data Coord = Coord { x :: Double, y :: Double } deriving / instance ToJSON Coord where toEncoding =  1 (Why do we provide an implementation for  here? The  function is a relatively new addition to this class. To allow users of older versions of this library to upgrade without having to edit all of their instances or encounter surprising incompatibilities, the default implementation of  uses Y. This produces correct results, but since it performs an intermediate conversion to a 7, it will be less efficient than directly emitting an { . Our one-liner definition of ! above bypasses the intermediate .If DefaultSignatures~ 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 : -instance ToJSON Coord where toJSON =  1 toEncoding =  1 =Convert a Haskell value to a JSON-friendly intermediate type.Encode 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  using the  DeriveGenericA extension, and then have GHC generate a method body as follows. -instance ToJSON Coord where toEncoding =  1 A " value either stores nothing (for _) or it stores the two function arguments that encode occurrences of the type parameter (for ).GClass of generic representation types that can be converted to a JSON {.This method (applied to 18) can be used as the default generic implementation of  (if the arity is 6) or  (if the arity is 5).EClass of generic representation types that can be converted to JSON.This method (applied to 14) is used as the default generic implementation of  (if the arity is 6) or  (if the arity is 5).?A configurable generic JSON creator. This function applied to 1 is used as the default for " when the type is an instance of .?A configurable generic JSON creator. This function applied to 1 is used as the default for " when the type is an instance of .?A configurable generic JSON encoder. This function applied to 1 is used as the default for " when the type is an instance of .?A configurable generic JSON encoder. This function applied to 1 is used as the default for " when the type is an instance of .!Helper for creating textual keys.  instance  MyKey where  = [ myKeyToText where myKeyToText = Text.pack . show -- or showt from text-show TODO: should this be exported?Contravariant map, as  is a contravariant functor.Lift the standard ' function through the type constructor.Lift the standard ' function through the type constructor.Lift the standard ' function through the type constructor.Lift the standard ' function through the type constructor.Helper function to use with . Useful when writing own  instances. Snewtype F a = F [a] -- This instance encodes String as an array of chars instance  F where  tj _ (F xs) =  tj ( tj) xs  te _ (F xs) =  te ( te) xs instance  F where  p _ v = F <$>  p ( p) v Helper function to use with , see .!Encode something t a JSON string.R      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~*(      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~8D(c) 2011-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableNone %&9:;<=T]56FGHIJKLPMNOQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvD(c) 2011-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableNone Encode a  as a JSON array. '()+,.0123456FGHIJKLPMNOQRSTUVWXYZ[\]^_`abcdefghijkmnopqrstuvx{~{~x'(aTUUVk),+0QRRSSLMNOP^_`IJJKbFGHcZ[WXY65\]efghijmnov.pqrstud 3412D(c) 2012-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableNoneEncode a JSON  to a Data.Text.LazyNote: uses Encode 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 , it is more efficient to use encodeToBuilder instead.Note: Uses D(c) 2011-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableNone -Efficiently serialize a JSON value as a lazy .$This is implemented in terms of the  class's  method.1Efficiently deserialize a JSON value from a lazy 5. If this fails due to incomplete or invalid input,  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 7 for details.3Efficiently deserialize a JSON value from a strict 5. If this fails due to incomplete or invalid input,  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 7 for details.1Efficiently deserialize a JSON value from a lazy 5. If this fails due to incomplete or invalid input,  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 8 for details.3Efficiently deserialize a JSON value from a strict 5. If this fails due to incomplete or invalid input,  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 8 for details.Like 2 but returns an error message when decoding fails.Like 2 but returns an error message when decoding fails.Like 2 but returns an error message when decoding fails.Like 2 but returns an error message when decoding fails. n.15678FGHIJKLPMNOQRSTUVWXYZ[\]bcefghijkmnovx{~w{~TUUVkQRRSSLMNOPIJJKbFGHcZ[WXY65\]1efghijxmnov.78 D(c) 2012-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3%Bryan O'Sullivan <bos@serpentine.com> experimentalportableNone C(c) 2011-2016 Bryan O'Sullivan (c) 2011 MailRank, Inc.BSD3 experimentalportableNone#9;DEWhether a type is not of kind *, is of kind *, or is a kind variable.5A representation of which typeclass is being derived.?A representation of which typeclass method is being spliced in.8Whether ToJSON(1)(2) or FromJSON(1)(2) is being derived.MA representation of the arity of the ToJSON/FromJSON typeclass being derived.Generates both  and TT instance declarations for the given data type or data family instance constructor.EThis is a convienience function which is equivalent to calling both  and .Generates both  and IT instance declarations for the given data type or data family instance constructor.EThis is a convienience function which is equivalent to calling both  and .Generates both  and FT instance declarations for the given data type or data family instance constructor.EThis is a convienience function which is equivalent to calling both  and  . Generates a S instance declaration for the given data type or data family instance constructor. Generates a S instance declaration for the given data type or data family instance constructor. Generates a S instance declaration for the given data type or data family instance constructor.jGenerates a lambda expression which encodes the given data type or data family instance constructor as a .jGenerates 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.jGenerates 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.vGenerates a lambda expression which encodes the given data type or data family instance constructor as a JSON string.Generates 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.Generates 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.Helper function used by both  and  . Generates code to generate a K of a number of constructors. All constructors must be from the same type.Helper function used by both  and r. Generates code to write out a value for a number of constructors. All constructors must be from the same type.If constructor is nullary.EGenerates code to generate the JSON encoding of a single constructor.EGenerates code to generate the JSON encoding of a single constructor. Generates a TS instance declaration for the given data type or data family instance constructor. Generates a IS instance declaration for the given data type or data family instance constructor.  Generates a FS instance declaration for the given data type or data family instance constructor. yGenerates a lambda expression which parses the JSON encoding of the given data type or data family instance constructor. Generates 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. Generates 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.Helper 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.BGenerates code to parse the JSON encoding of a single constructor.CGenerates code to parse the JSON encoding of an n-ary constructor.Functionality common to , , and .Functionality common to deriveToJSON(1)(2) and deriveFromJSON(1)(2)."Boilerplate for top level splices. The given  must meet one of two criteria: JIt must be the name of a type constructor of a plain data type or newtype.NIt must be the name of a data family instance or newtype instance constructor.MInfer the context and instance head needed for a FromJSON or ToJSON instance.Attempt 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.KIf a VarT is missing an explicit kind signature, steal it from a TyVarBndr..Extracts the kind from a type variable binder."Returns True if a Type has kind *.GGets all of the type/kind variable names mentioned somewhere in a Kind.hasKindVarChain 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.EIf a Type is a SigT, returns its kind signature. Otherwise, return *.iExtract Just the Name from a type variable. If the argument Type is not a type variable, return Nothing.dExtract the Name from a type variable. If the argument Type is not a type variable, throw an error.%Extracts the name from a constructor.7Fully applies a type constructor to its type variables.Is the given type a variable?PIs the given type a type family constructor (and not a data family constructor)?6Peel off a kind signature from a Type (if it has one).AAre all of the items in a list (which have an ordering) distinct?HThis uses Set (as opposed to nub) for better asymptotic time complexity.9Does the given type mention any of the Names in the list?@Does an instance predicate mention any of the Names in the list? HSplit an applied type into its individual components. For example, this: Either Int Char would split to this: [Either, Int, Char]  ESplit 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, ()])  )Like uncurryType, except on a kind level. <Makes a string literal expression from a constructor's name. >Creates a string literal expression from a record field label.The name of the outermost  constructor.Checks 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 typesBExpands all type synonyms in a type. Written by Dan Rosn in the  genifunctors package (licensed under BSD3).Either the given data type doesn't have enough type variables, or one of the type variables to be eta-reduced cannot realize kind *.}One of the last type variables cannot be eta-reduced (see the canEtaReduce function for the criteria it would have to meet).ZThe data type has a DatatypeContext which mentions one of the eta-reduced type variables.The 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.bThe data type has an existential constraint which mentions one of the eta-reduced type variables.8Does a Type have kind * or k (for some kind variable k)?Returns  the kind variable  of a # if it exists. Otherwise, returns .jConcat together all of the StarKindStatuses that are IsKindVar and extract the kind variables' Names out. !"#$%&'()*+,Encoding options.'Name of the type for which to generate  and T instances.Encoding options.'Name of the type for which to generate  and I instances.Encoding options.'Name of the type for which to generate  and F instances.Encoding options.)Name of the type for which to generate a  instance declaration.Encoding options.)Name of the type for which to generate a  instance declaration.Encoding options.)Name of the type for which to generate a  instance declaration.-!The ToJSON variant being derived.Encoding options.3Name of the type for which to generate an instance.Encoding options.Name of the type to encode.Encoding options.Name of the type to encode.Encoding options.Name of the type to encode..&Which class's method is being derived.Encoding options.Name of the encoded type.Encoding options.Name of the type to encode.Encoding options.Name of the type to encode.Encoding options.Name of the type to encode./&Which class's method is being derived.Encoding options.Name of the encoded type.!The ToJSON variant being derived.Encoding options.8Constructors for which to generate JSON generating code.012!The ToJSON variant being derived.Encoding options.8Constructors for which to generate JSON generating code.3456789:;<=Encoding options.)Name of the type for which to generate a T instance declaration.Encoding options.)Name of the type for which to generate a I instance declaration. Encoding options.)Name of the type for which to generate a  FromJSON3 instance declaration.>#The FromJSON variant being derived.Encoding options.AName of the type for which to generate an instance. declaration. Encoding options.Name of the encoded type. Encoding options.Name of the encoded type. Encoding options.Name of the encoded type.?&Which class's method is being derived.Encoding options.Name of the encoded type.#The FromJSON variant being derived.2Name of the type to which the constructors belong.Encoding options5Constructors for which to generate JSON parsing code.@ABCD#The FromJSON variant being derived.6The names of the encoding/decoding function arguments.2Name of the type to which the constructor belongs.Encoding options.4Constructor for which to generate JSON parsing code.0Left (valFieldName, objName) or Right valName#The FromJSON variant being derived.EMaps the last type variables to their decoding function arguments.&The argument types of the constructor.2Name of the type to which the constructor belongs.Estructor name.Estructor arity.FGHIJKLMNOPQRSTU#Function which derives a flavor of .#Function which derives a flavor of T.Encoding options.'Name of the type for which to generate  and T instances.6The class methods and the functions which derive them.,The class for which to generate an instance.Encoding options.EName of the type for which to generate a class instance declaration.V*The function which derives the expression.&Which class's method is being derived.Encoding options.Name of the encoded type.WXYZVFunction that generates the actual code. Will be applied to the datatype/data family V, datatype context, type variable binders and constructors extracted from the given  . If the o is from a data family instance constructor, it will also have its instantiated types; otherwise, it will be .Resulting value in the [ uasi monad.(The type constructor or data family nameThe typeclass to deriveThe datatype context=The type variables from the data type/data family declaration; the types used to instantiate a data family instance, or  if it's a plain data typeThe resulting \ and ]9 to use in a class instance Plain data type/newtype case^(The type constructor or data family nameThe typeclass to deriveThe datatype context*The types to instantiate the instance with+True if it's a data family, False otherwise_`abcd   e  Encoding optionsfghijklmnopqrstuvwxy # 12    # 12     !"#$%&'()*+,-./0123456789:;<= >   ?@ABCDFGHIJKLMNOPQRSTUVWXYZ^_`abcd   e  fghijklmnopqrstuvwxy 768594z    ! " # $ % % & ' ( ) * + , - - . / 0 1 2 3 4 5 1 0 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O PQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~/S                         ! " #$%&$%'()*+,- 9 . /()0(12(13 6 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ' & ^ ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z {|}~($($%$((()2()(()(()3$%4      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~H$%$%((      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~(                                                 !()" # $ % &  ' (  ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A  H  B C D E F  G HI J K L M N O P Q R S T U V W X Y Z [ \ ] ^_`a b c d e f g h i j k l m n o p q r s t u v w x y z { | }~$aeson-1.1.1.0-Kn3XSA7wpxuJTddIagwlNjData.Aeson.TypesData.Aeson.InternalData.Aeson.ParserData.Aeson.Internal.TimeData.Aeson.Encoding.InternalData.Aeson.Text Data.AesonData.Aeson.Encode Data.Aeson.THData.Aeson.Types.InternalData.Aeson.Types.GenericData.Aeson.Parser.UnescapeFFIData.Aeson.Parser.UnescapeData.Aeson.Parser.InternalData.Aeson.Parser.TimeData.Aeson.Internal.FunctionsData.Aeson.Types.FromJSONData.Aeson.ToJSON listEncodingData.Aeson.Encoding.BuilderData.Aeson.EncodingData.Aeson.Types.ToJSONData.Aeson.FromJSON FromJSON1 liftParseJSON listParserData.Aeson.Types.ClassL ByteString SumEncoding TaggedObject UntaggedValueObjectWithSingleField TwoElemArray tagFieldNamecontentsFieldNameOptionsfieldLabelModifierconstructorTagModifierallNullaryToStringTagomitNothingFields sumEncodingunwrapUnaryRecordsPair DotNetTimefromDotNetTimeValueObjectArrayStringNumberBoolNullParserResultErrorSuccessIResultIErrorISuccessJSONPathJSONPathElementKeyIndex emptyArray emptyObjectparseiparse parseMaybe parseEither formatErrorobject modifyFailuredefaultOptionsdefaultTaggedObjectcamelTocamelTo2OneZerojsonjson'valuevalue'jstring decodeWithdecodeStrictWitheitherDecodeWitheitherDecodeStrictWith TimeOfDay64TODtoPicofromPicodiffTimeOfDay64 toTimeOfDay64 FromJSON2liftParseJSON2liftParseJSONList2liftParseJSONListFromJSONKeyFunctionFromJSONKeyCoerceFromJSONKeyTextFromJSONKeyTextParserFromJSONKeyValue FromJSONKey fromJSONKeyfromJSONKeyListFromJSON parseJSON parseJSONListFromArgs NoFromArgs From1Args GFromJSON gParseJSONgenericParseJSONgenericLiftParseJSONfromJSONKeyCoercecoerceFromJSONKeyFunctionmapFromJSONKeyFunction typeMismatch parseJSON1 parseJSON2 withObjectwithText withArray withNumberwithScientificwithBoolfromJSON ifromJSON.:.:?.:! parseFieldparseFieldMaybeparseFieldMaybe'explicitParseFieldexplicitParseFieldMaybeexplicitParseFieldMaybe'.!=InArraySeriesEmptyEncoding Encoding' fromEncodingunsafeToEncodingencodingToLazyByteString retagEncodingpairpair' nullEncoding emptyArray_ emptyObject_ wrapArray wrapObjectnull_boolpairslistdict>*<emptyeconcat><tupletextlazyTextstringcommacolon openBracket closeBracket openCurly closeCurlyint8int16int32int64intword8word16word32word64wordintegerfloatdouble scientificint8Text int16Text int32Text int64TextintText word8Text word16Text word32Text word64TextwordText integerText floatText doubleTextscientificTextday localTimeutcTime timeOfDay zonedTime$fMonoidSeries$fSemigroupSeries$fOrdEncoding' $fEqEncoding'$fShowEncoding'ToJSON2 liftToJSON2liftToJSONList2liftToEncoding2liftToEncodingList2ToJSON1 liftToJSONliftToJSONListliftToEncodingliftToEncodingListToJSONKeyFunction ToJSONKeyTextToJSONKeyValue ToJSONKey toJSONKey toJSONKeyListKeyValue.=ToJSONtoJSON toEncoding toJSONListtoEncodingListToArgsNoToArgsTo1Args GToEncoding gToEncodingGToJSONgToJSON genericToJSONgenericLiftToJSONgenericToEncodinggenericLiftToEncoding toJSONKeyTextcontramapToJSONKeyFunctiontoJSON1 toEncoding1toJSON2 toEncoding2 listValuefoldableencodeToLazyTextencodeToTextBuilderencodedecode decodeStrictdecode' decodeStrict' eitherDecodeeitherDecodeStrict eitherDecode'eitherDecodeStrict' deriveJSON deriveJSON1 deriveJSON2 deriveToJSON deriveToJSON1 deriveToJSON2mkToJSON mkLiftToJSON mkLiftToJSON2 mkToEncodingmkLiftToEncodingmkLiftToEncoding2deriveFromJSONderiveFromJSON1deriveFromJSON2 mkParseJSONmkLiftParseJSONmkLiftParseJSON2$fLookupFieldMaybe$fLookupFielda $fEnumArity $fEqArity $fOrdArity$fEqStarKindStatusghc-prim GHC.TypesTrueFalsebaseGHC.BaseNothing time-1.6.0.1Data.Time.Clock.UTCUTCTimeFailure isEmptyArrayMaybe Data.EitherEitherLeft runParserapP hashValue $fShowOptions $fLiftValue$fHashableValue$fIsStringValue $fNFDataValue$fMonoidParser$fSemigroupParser$fMonadPlusParser$fAlternativeParser$fApplicativeParser$fFunctorParser$fMonadFailParser $fMonadParser$fTraversableResult$fTraversableIResult$fFoldableResult$fFoldableIResult$fMonoidResult$fSemigroupResult$fMonoidIResult$fSemigroupIResult$fAlternativeResult$fAlternativeIResult$fMonadPlusResult$fMonadPlusIResult$fApplicativeResult$fApplicativeIResult$fMonadFailResult $fMonadResult$fMonadFailIResult$fMonadIResult$fFunctorResult$fFunctorIResult$fNFDataResult$fNFDataIResult$fNFDataJSONPathElement ProductSize productSizeAndTagged2 unTagged2 AllNullaryIsRecordisUnary$fProductSizeM1$fProductSize:*:$fAndTrueFalseFalse$fAndFalseTrueFalse$fAndFalseFalseFalse$fAndTrueTrueTrue$fAllNullaryU1True$fAllNullaryRec1False$fAllNullaryPar1False$fAllNullaryK1False$fAllNullary:.:False$fAllNullary:*:False$fAllNullaryM1allNullary$fAllNullary:+:allNullary$fIsRecordU1False$fIsRecord:.:True$fIsRecordRec1True$fIsRecordPar1True$fIsRecordK1True$fIsRecordM1isRecord$fIsRecordM1False$fIsRecord:*:isRecord c_js_decode unescapeText' unescapeTextjstring_jsonEOFjsonEOF' skipSpaceSPSobject_object_' objectValuesarray_array_' arrayValuesdecimal0run twoDigitssecondstimeZoneTutc mapHashKeyValcontainers-0.5.7.1 Data.Map.BaseMap3unordered-containers-0.2.8.0-5pNp3l8vBzrGaRUqynRgkTData.HashMap.BaseHashMap mapKeyValmapKey GHC.GenericsGeneric1GHC.Primcoerce Unsafe.Coerce unsafeCoerce#text-1.2.2.1-9Yh8rJoh8fO2JMLWffT3QsData.Text.InternalText CoerceText Coercible GHC.ClassesEq'hashable-1.2.6.0-EikjbjmXLfl2FtsVIjLwnCData.Hashable.ClassHashableGHC.ReadreadListReadfail Data.Functor<$><*>Genericfmap*attoparsec-0.13.1.0-2oAWBIJPQOW2f7BOIV5Ng9Data.Attoparsec.Number*scientific-0.3.4.10-AEQHfxbjE7xH7knuC7wOodData.Scientific Scientific$fFromJSONNominalDiffTime$fFromJSONInteger$fFromJSONFixed$fFunctorFromJSONKeyFunctionFromUntaggedValueparseUntaggedValueFromPair parsePair FromProduct parseProduct FromRecord parseRecord ConsFromJSON'consParseJSON' ConsFromJSON consParseJSONFromTaggedObject''parseFromTaggedObject''FromTaggedObject'parseFromTaggedObject'FromTaggedObjectparseFromTaggedObject SumFromStringparseSumFromStringParseSumparseSumcoerce'parseIndexedJSONparseIndexedJSONPairparseJSONElemAtIndexscientificToNumberparseRealFloatparseIntegralFromScientific parseIntegral"parseBoundedIntegralFromScientificparseBoundedIntegralparseScientificTextparseIntegralTextparseBoundedIntegralTextparseOptionalFieldWithparseAllNullarySumparseNonAllNullarySumnotFoundparseVersionTextvectorParseJSON$fFromJSON(,,,,,,,,,,,,,,)$fFromJSON1(,,,,,,,,,,,,,,)$fFromJSON2(,,,,,,,,,,,,,,)$fFromJSON(,,,,,,,,,,,,,)$fFromJSON1(,,,,,,,,,,,,,)$fFromJSON2(,,,,,,,,,,,,,)$fFromJSON(,,,,,,,,,,,,)$fFromJSON1(,,,,,,,,,,,,)$fFromJSON2(,,,,,,,,,,,,)$fFromJSON(,,,,,,,,,,,)$fFromJSON1(,,,,,,,,,,,)$fFromJSON2(,,,,,,,,,,,)$fFromJSON(,,,,,,,,,,)$fFromJSON1(,,,,,,,,,,)$fFromJSON2(,,,,,,,,,,)$fFromJSON(,,,,,,,,,)$fFromJSON1(,,,,,,,,,)$fFromJSON2(,,,,,,,,,)$fFromJSON(,,,,,,,,)$fFromJSON1(,,,,,,,,)$fFromJSON2(,,,,,,,,)$fFromJSON(,,,,,,,)$fFromJSON1(,,,,,,,)$fFromJSON2(,,,,,,,)$fFromJSON(,,,,,,)$fFromJSON1(,,,,,,)$fFromJSON2(,,,,,,)$fFromJSON(,,,,,)$fFromJSON1(,,,,,)$fFromJSON2(,,,,,)$fFromJSON(,,,,)$fFromJSON1(,,,,)$fFromJSON2(,,,,)$fFromJSON(,,,)$fFromJSON1(,,,)$fFromJSON2(,,,)$fFromJSON(,,)$fFromJSON1(,,)$fFromJSON2(,,) $fFromJSON(,)$fFromJSON1(,)$fFromJSON2(,)$fFromJSONKey[]$fFromJSONKeyChar$fFromJSONKey(,,,)$fFromJSONKey(,,)$fFromJSONKey(,)$fFromJSONKeyTagged$fFromJSONTagged$fFromJSON1Tagged$fFromJSON2Tagged$fFromJSONProxy$fFromJSON1Proxy$fFromJSONOption$fFromJSON1Option$fFromJSONWrappedMonoid$fFromJSON1WrappedMonoid$fFromJSONLast$fFromJSON1Last$fFromJSONFirst$fFromJSON1First $fFromJSONMax$fFromJSON1Max $fFromJSONMin$fFromJSON1Min$fFromJSONLast0$fFromJSON1Last0$fFromJSONFirst0$fFromJSON1First0$fFromJSONDual$fFromJSON1Dual$fFromJSONKeyUTCTime$fFromJSONUTCTime$fFromJSONKeyZonedTime$fFromJSONZonedTime$fFromJSONKeyLocalTime$fFromJSONLocalTime$fFromJSONKeyTimeOfDay$fFromJSONTimeOfDay$fFromJSONKeyDay $fFromJSONDay$fFromJSONDotNetTime$fFromJSONValue$fFromJSONHashMap$fFromJSON1HashMap$fFromJSONHashSet$fFromJSONVector$fFromJSONVector0$fFromJSONVector1$fFromJSONVector2$fFromJSON1Vector$fFromJSONKeyUUID$fFromJSONUUID$fFromJSONTree$fFromJSON1Tree $fFromJSONMap$fFromJSON1Map$fFromJSONIntMap$fFromJSON1IntMap$fFromJSONIntSet $fFromJSONSet $fFromJSONSeq$fFromJSON1Seq $fFromJSONSum$fFromJSON1Sum$fFromJSONProduct$fFromJSON1Product$fFromJSONCompose$fFromJSON1Compose$fFromJSONKeyIdentity$fFromJSONIdentity$fFromJSON1Identity$fFromJSONDList$fFromJSON1DList$fFromJSONScientific$fFromJSONNonEmpty$fFromJSON1NonEmpty$fFromJSONKeyVersion$fFromJSONVersion$fFromJSONKeyText$fFromJSONText$fFromJSONKeyText0$fFromJSONText0$fFromJSONKeyWord64$fFromJSONWord64$fFromJSONKeyWord32$fFromJSONWord32$fFromJSONKeyWord16$fFromJSONWord16$fFromJSONKeyWord8$fFromJSONWord8$fFromJSONKeyWord$fFromJSONWord$fFromJSONKeyInt64$fFromJSONInt64$fFromJSONKeyInt32$fFromJSONInt32$fFromJSONKeyInt16$fFromJSONInt16$fFromJSONKeyInt8$fFromJSONInt8$fFromJSONKeyNatural$fFromJSONNatural$fFromJSONKeyInteger$fFromJSONKeyInt $fFromJSONInt$fFromJSONRatio$fFromJSONKeyFloat$fFromJSONFloat$fFromJSONNumber$fFromJSONKeyDouble$fFromJSONDouble$fFromJSONChar $fFromJSON()$fFromJSONOrdering$fFromJSONKeyBool$fFromJSONBool$fFromJSONEither$fFromJSON1Either$fFromJSON2Either$fFromJSONMaybe$fFromJSON1Maybe$fFromJSONConst$fFromJSON1Const$fFromJSON2Const$fFromUntaggedValuearityM1$fFromUntaggedValuearityM10$fFromUntaggedValuearity:+:$fFromPairarityM1$fFromPairarity:+:$fFromProductarityM1$fFromProductarity:*:$fFromRecordarityM1$fFromRecordarityM10$fFromRecordarity:*:$fConsFromJSON'TYPEarityfFalse$fConsFromJSON'TYPEarityfTrue$fConsFromJSONarityf$$fFromTaggedObject''TYPEarityU1False#$fFromTaggedObject''TYPEarityfFalse"$fFromTaggedObject''TYPEarityfTrue$fFromTaggedObject'arityf$fFromTaggedObjectarityM1$fFromTaggedObjectarity:+:$fSumFromStringTYPEM1$fSumFromStringTYPE:+:$fParseSumTYPEarity:+:False$fParseSumTYPEarity:+:True$fGFromJSONOne:.:$fGFromJSONarity:+:$fGFromJSONarity:*:$fGFromJSONarityM1$fGFromJSONarityU1$fGFromJSONOneRec1$fGFromJSONOnePar1$fGFromJSONarityK1$fGFromJSONarityM10 $fFromJSON[] $fFromJSON1[]encodeToBuilderbytestring-0.10.8.1 Data.ByteString.Builder.InternalBuilderarrayunquotedquote escapeAsciic2wascii2ascii4ascii5ascii6ascii8 timeOfDay64dayTimedigitrealFloatToEncoding GetConNameCharIntGHC.ShowShow Data.Monoid<>toJSONKeyTextEncstringEncodingUntaggedValueEncuntaggedValueEncUntaggedValueObjuntaggedValueObjObjectWithSingleFieldEncobjectWithSingleFieldEncObjectWithSingleFieldObjobjectWithSingleFieldObj EncodeProduct encodeProduct WriteProduct writeProductRecordToEncodingrecordToEncoding RecordToPairs recordToPairsConsToEncoding'consToEncoding'ConsToEncodingconsToEncoding ConsToJSON' consToJSON' ConsToJSON consToJSONTwoElemArrayEnctwoElemArrayEncTwoElemArrayObjtwoElemArrayObj getConNameTaggedObjectEnc'taggedObjectEnc'TaggedObjectEnctaggedObjectEncTaggedObjectPairs'taggedObjectPairs'TaggedObjectPairstaggedObjectPairs SumToEncoding sumToEncoding SumToJSON sumToJSON toJSONPairrealFloatToJSONnonAllNullarySumToJSONnonAllNullarySumToEncoding fieldToPairfieldToEncodingorderingToText encodeVector vectorToJSON dotNetTime formatMillislazyToStrictByteString$fToJSON(,,,,,,,,,,,,,,)$fToJSON1(,,,,,,,,,,,,,,)$fToJSON2(,,,,,,,,,,,,,,)$fToJSON(,,,,,,,,,,,,,)$fToJSON1(,,,,,,,,,,,,,)$fToJSON2(,,,,,,,,,,,,,)$fToJSON(,,,,,,,,,,,,)$fToJSON1(,,,,,,,,,,,,)$fToJSON2(,,,,,,,,,,,,)$fToJSON(,,,,,,,,,,,)$fToJSON1(,,,,,,,,,,,)$fToJSON2(,,,,,,,,,,,)$fToJSON(,,,,,,,,,,)$fToJSON1(,,,,,,,,,,)$fToJSON2(,,,,,,,,,,)$fToJSON(,,,,,,,,,)$fToJSON1(,,,,,,,,,)$fToJSON2(,,,,,,,,,)$fToJSON(,,,,,,,,)$fToJSON1(,,,,,,,,)$fToJSON2(,,,,,,,,)$fToJSON(,,,,,,,)$fToJSON1(,,,,,,,)$fToJSON2(,,,,,,,)$fToJSON(,,,,,,)$fToJSON1(,,,,,,)$fToJSON2(,,,,,,)$fToJSON(,,,,,)$fToJSON1(,,,,,)$fToJSON2(,,,,,)$fToJSON(,,,,)$fToJSON1(,,,,)$fToJSON2(,,,,) $fToJSON(,,,)$fToJSON1(,,,)$fToJSON2(,,,) $fToJSON(,,) $fToJSON1(,,) $fToJSON2(,,) $fToJSON(,) $fToJSON1(,) $fToJSON2(,) $fToJSONKey[]$fToJSONKeyChar$fToJSONKey(,,,)$fToJSONKey(,,)$fToJSONKey(,)$fToJSONKeyTagged$fToJSONTagged$fToJSON1Tagged$fToJSON2Tagged $fToJSONProxy$fToJSON1Proxy$fToJSONOption$fToJSON1Option$fToJSONWrappedMonoid$fToJSON1WrappedMonoid $fToJSONLast $fToJSON1Last $fToJSONFirst$fToJSON1First $fToJSONMax $fToJSON1Max $fToJSONMin $fToJSON1Min $fToJSONLast0$fToJSON1Last0$fToJSONFirst0$fToJSON1First0 $fToJSONDual $fToJSON1Dual$fToJSONNominalDiffTime$fToJSONKeyUTCTime$fToJSONUTCTime$fToJSONKeyZonedTime$fToJSONZonedTime$fToJSONKeyLocalTime$fToJSONLocalTime$fToJSONKeyTimeOfDay$fToJSONTimeOfDay$fToJSONKeyDay $fToJSONDay$fToJSONDotNetTime $fToJSONValue$fToJSONHashMap$fToJSON1HashMap$fToJSONHashSet$fToJSON1HashSet$fToJSONVector$fToJSONVector0$fToJSONVector1$fToJSONVector2$fToJSON1Vector$fToJSONKeyUUID $fToJSONUUID $fToJSONTree $fToJSON1Tree $fToJSONMap $fToJSON1Map$fToJSONIntMap$fToJSON1IntMap$fToJSONIntSet $fToJSONSet $fToJSON1Set $fToJSONSeq $fToJSON1Seq $fToJSONSum $fToJSON1Sum$fToJSONProduct$fToJSON1Product$fToJSONCompose$fToJSON1Compose$fToJSONKeyIdentity$fToJSONIdentity$fToJSON1Identity $fToJSONDList$fToJSON1DList$fToJSONKeyScientific$fToJSONScientific$fToJSONNonEmpty$fToJSON1NonEmpty$fToJSONKeyVersion$fToJSONVersion$fToJSONKeyText $fToJSONText$fToJSONKeyText0 $fToJSONText0$fToJSONKeyWord64$fToJSONWord64$fToJSONKeyWord32$fToJSONWord32$fToJSONKeyWord16$fToJSONWord16$fToJSONKeyWord8 $fToJSONWord8$fToJSONKeyWord $fToJSONWord$fToJSONKeyInt64 $fToJSONInt64$fToJSONKeyInt32 $fToJSONInt32$fToJSONKeyInt16 $fToJSONInt16$fToJSONKeyInt8 $fToJSONInt8$fToJSONKeyNatural$fToJSONNatural$fToJSONKeyInteger$fToJSONInteger$fToJSONKeyInt $fToJSONInt$fToJSONKeyFixed $fToJSONFixed $fToJSONRatio$fToJSONKeyFloat $fToJSONFloat$fToJSONNumber$fToJSONKeyDouble$fToJSONDouble $fToJSONChar $fToJSON()$fToJSONOrdering$fToJSONKeyBool $fToJSONBool$fToJSONEither$fToJSON1Either$fToJSON2Either $fToJSONMaybe$fToJSON1Maybe $fToJSONConst$fToJSON1Const$fToJSON2Const$fUntaggedValueEncarityM1$fUntaggedValueEncarityM10$fUntaggedValueEncarity:+:$fUntaggedValueObjarityM1$fUntaggedValueObjarityM10$fUntaggedValueObjarity:+:!$fObjectWithSingleFieldEncarityM1"$fObjectWithSingleFieldEncarity:+:!$fObjectWithSingleFieldObjarityM1"$fObjectWithSingleFieldObjarity:+:$fEncodeProductaritya$fEncodeProductarity:*:$fWriteProductaritya$fWriteProductarity:*:$fRecordToEncodingarityM1$fRecordToEncodingarityM10$fRecordToEncodingarity:*:$fRecordToPairsarityM1$fRecordToPairsarityM10$fRecordToPairsarity:*: $fConsToEncoding'TYPEarityfFalse$fConsToEncoding'TYPEarityfTrue$fConsToEncodingarityf$fConsToJSON'TYPEarityfFalse$fConsToJSON'TYPEarityfTrue$fConsToJSONarityf$fTwoElemArrayEncarityM1$fTwoElemArrayEncarity:+:$fTwoElemArrayObjarityM1$fTwoElemArrayObjarity:+:$fGetConNameTYPEM1$fGetConNameTYPE:+:!$fTaggedObjectEnc'TYPEarityfFalse $fTaggedObjectEnc'TYPEarityfTrue"$fTaggedObjectEnc'TYPEarityU1False$fTaggedObjectEncarityM1$fTaggedObjectEncarity:+:#$fTaggedObjectPairs'TYPEarityfFalse"$fTaggedObjectPairs'TYPEarityfTrue$$fTaggedObjectPairs'TYPEarityU1False$fTaggedObjectPairsarityM1$fTaggedObjectPairsarity:+:$fSumToEncodingTYPEarityfFalse$fSumToEncodingTYPEarityfTrue$fSumToJSONTYPEarityfFalse$fSumToJSONTYPEarityfTrue$fGToEncodingOne:.:$fGToEncodingarity:+:$fGToEncodingarity:*:$fGToEncodingarityM1$fGToEncodingarityU1$fGToEncodingOneRec1$fGToEncodingOnePar1$fGToEncodingarityK1$fGToEncodingarityM10$fGToJSONOne:.:$fGToJSONarity:+:$fGToJSONarity:*:$fGToJSONarityM1$fGToJSONarityU1$fGToJSONOneRec1$fGToJSONOnePar1$fGToJSONarityK1$fGToJSONarityM10 $fToJSON[] $fToJSON1[] $fKeyValue(,)$fKeyValueSeries Data.FoldableFoldableData.Text.Internal.BuilderfromScientificData.ByteString.Lazy.InternalData.ByteString.InternaleitherFormatErrorStarKindStatus JSONClassJSONFun DirectionArity consToValue isNullary argsToValueargsToEncoding consFromJSON parseArgsderiveJSONBothderiveJSONClasswithTypetemplate-haskellLanguage.Haskell.TH.SyntaxNamebuildTypeInstancederiveConstraintstealKindForTypetvbKind hasKindStartyVarNamesOfKindhasKindVarChaintyKindvarTToNameMaybe varTToName applyTyConisTyVar isTyFamilyunSigT allDistinct mentionsNamepredMentionsName unapplyTy uncurryTy uncurryKind conNameExp fieldLabelExp valueConName canEtaReduce expandSynderivingKindErroretaReductionErrordatatypeContextErroroutOfPlaceTyVarErrorexistentialContextErrorcanRealizeKindStarstarKindStatusToNameJustcatKindVarNames NotKindStarKindStar IsKindVar directionarity ToEncoding ParseJSONToFromArity0Arity1Arity2 KindSubst TypeSubstTyVarMap LookupField lookupFieldderiveToJSONCommonmkToJSONCommonmkToEncodingCommonconStrconTxt conStringEencStr sumToValuenullarySumToValueisMaybe<^><:><%>nullarySumToEncodingderiveFromJSONCommonmkParseJSONCommonparseNullaryMatchesparseUnaryMatches getValField matchCasesCon matchFailedparseTypeMismatchlookupFieldWithkeyValuePairWithunknownFieldFail noArrayFail noObjectFailfirstElemNoStringFailwrongPairCountFail noStringFail noMatchFail not2ElemArrayconNotFoundFail2ElemArray conNotFoundFailObjectSingleFieldconNotFoundFailTaggedObjectparseTypeMismatch' mkFunCommondispatchFunByTypedispatchToJSONdispatchToEncodingdispatchParseJSONQCxtTypebuildTypeInstanceFromTys reifyConTys tvbToType isStarOrVar newNameListtyVarNamesOfType interleavecreateKindChainapplyCon expandSynKind expandSynAppmkSubst substType substKindsubstNameWithKindsubstNamesWithKindStar toJSONClass toJSON1Class toJSON2Class fromJSONClassfromJSON1ClassfromJSON2Class jsonClassNamejsonFunValNamejsonFunListNamejsonFunValOrListNamearityInt allowExQuant