Aԡ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+, - . / 0 1 2 3 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 { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 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 jklmnopqrstuvwxyz{|}~Safe!"fSafe!"OTfAGet the list of keys from an ordered map, in order of appearance..This list is guaranteed to have no duplicates.@Convert an ordered map to a regular map, losing insertion order.Convert an ordered map to a list of keys and values. The list is guaranteed to be the same order as the order of insertion into the map. O(n log n)>Generate an ordered map with the given key & value generators.The empty OrderedMap. O(1)1Create an ordered map containing a single entry. O(1) Find a value in an ordered map.O(log n) <Get the values from an ordered map, in order of appearance.  O(n log n) $The union of a list of ordered maps.3If any map shares a key with any other map, return .Otherwise, return a new map containing all of the keys from all of the maps. The keys from the first map will appear first, followed by the second, and so forth.O(m * n log (m * n)) where m is the number of maps, and n! is the size of the largest map. cAppend the second ordered map to the first, combining any shared elements with the given function. zAppend together a list of ordered maps, preserving ordering of keys. Combine any shared elements with the given function.Take two ordered maps, append the second one to the first. If the second contains any keys that also appear in the first, combine the two values with the given function.qTake a list of ordered maps and append them together. Any shared elements are combined using the given function.Take an ordered map with . values and return the same map with all the  values removed.%Construct an ordered map from a list. O(n log n).1If the list contains duplicate keys, then return . Otherwise, return an , preserving the order.      Safe!"OTfGenerate arbitrary .Generate an arbitrary  list.None !",OTftA t- is a document that defines a GraphQL schema. 3https://facebook.github.io/graphql/#sec-Type-SystemyA y# is something a user might send us. ?https://facebook.github.io/graphql/#sec-Language.Query-Document|A name in GraphQL. -https://facebook.github.io/graphql/#sec-Names~ Parser for |.n !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~e !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOWXUQRSTVPYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~e|}~yz{tuvwxpqrsnolmjkiefghcdb`a^_\]Z[YOPQRSTUVWXMNKLIJGHFDE@ABC>?<=9:;12345678/0.,-+)*'(%&#$!" 3 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO PQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None !",DOTfXTypes that implement this have values with a single canonical name in a GraphQL schema. e.g. a field foo(bar: Int32) would have the name "foo".WIf a thing *might* have a name, or has a name that might not be valid, don't use this.7If a thing is aliased, then return the *original* name.Get the name of the object.An invalid name. Create a |.Names must match the regex [_A-Za-z][_0-9A-Za-z]*4. If the given text does not match, return Nothing.makeName "foo"Right (Name {unName = "foo"})makeName "9-bar"Left (NameError "9-bar")Convert a type-level  into a GraphQL |. Create a |), panicking if the given text is invalid.Prefer  to this in all cases.unsafeMakeName "foo"Name {unName = "foo"} |} |}None!"f7      !"#$%&'()*+,7      !"#$%&'()*+,None!":fParser for a schema document.5-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^5-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^None!"29:;DIORT[bf3A field of an object that has a non-variable value.8A GraphQL object that contains only non-variable values.A GraphQL object. Note that  0https://facebook.github.io/graphql/#sec-ResponseP calls these "Maps", but everywhere else in the spec refers to them as objects.0A list of values that are known to be constants.Note that this list might not be valid GraphQL, because GraphQL only allows homogeneous lists (i.e. all elements of the same type), and we do no type checking at this point._^A value which contains no other values, and might be a variable that might lack a definition.4A non-variable value which contains no other values.cA GraphQL value which might contain some variables. These variables are not yet associated with < 6https://facebook.github.io/graphql/#VariableDefinition" variable definitions> (see also  .), which are provided in a different context.,A GraphQL value which contains no variables.A GraphQL value. scalarC represents the type of scalar that's contained within this value.Normally, it is one of either : (to indicate that there are no variables whatsoever) or VariableScalar3 (to indicate that there might be some variables).`2Generate an arbitrary value, with objects at most n levels deep.5If a value is an object, return just that. Otherwise Nothing.a)Convert a constant scalar to an AST.Valueb)Convert a variable scalar to an AST.ValuecBConvert a value from the AST into a variable scalar, presuming it is a scalar.d8Generate an arbitrary object to the given maximum depth.,Make an object from a list of object fields.#Make an object from an ordered map.4Create an object from a list of (name, value) pairs.e*Convert an AST value into a literal value.YThis is a stop-gap until we have proper conversion of user queries into canonical forms.)Convert an AST value to a variable value.VWill fail if the AST value contains duplicate object fields, or is otherwise invalid. Convert a value to an AST value.)Convert a variable value to an AST value.f*Convert a literal value into an AST value.!Nulls are converted into Nothing.This function probably isn't particularly useful, but it functions as a stop-gap until we have QuickCheck generators for the AST.#Generate an arbitrary scalar value.Cg_hijklmn`abcdef     (|}n'|}6g_hijklmn`abcdef      None!"IfoDA literal value specified as a default as part of a type definition.hUse this type alias when you want to be clear that a definition may include some sort of default value.Arguments (see E() and fields within input objects (see 3H) can have default values. These are allowed to be any kind of literal.;"Types that are built into GraphQL.7The GraphQL spec refers to these as "[scalars](https:/facebook.github.iographql/#sec-Scalars)".<,A signed 32 bit numeric non fractional value= True or false>5Textual data represented as UTF-8 character sequences?:Signed double precision fractional values as specified by 1https://en.wikipedia.org/wiki/IEEE_floating_pointIEEE 754@NA unique identifier, often used to refetch an object or as the key for a cache`@A thing that defines types. Excludes definitions of input types.aGet the types defined by t>TODO: This ignores whether a value can define multiple types with the same name, and further admits the possibility that the name embedded in the type definition does not match the name in the returned dictionary. jml would like to have a schema validation phase that eliminates one or both of these possibilities.FAlso pretty much works because we've inlined all our type definitions.dAn entire GraphQL schema.This is very much a work in progress. Currently, the only thing we provide is a dictionary mapping type names to their definitions.e%Create a schema from the root object.This is technically an insufficient API, since not all types in a schema need to be reachable from a single root object. However, it's a start.f0Find the type with the given name in the schema.p%Get the type that is being annotated.g:Does the given object type match the given type condition.See 8https://facebook.github.io/graphql/#sec-Field-Collection DoesFragmentTypeApply(objectType, fragmentType) If fragmentType is an Object Type: if objectType and fragmentType are the same type, return true, otherwise return false. If fragmentType is an Interface Type: if objectType is an implementation of fragmentType, return true otherwise return false. If fragmentType is a Union: if objectType is a possible type of fragmentType, return true otherwise return false. \o,-./012qr3456789:;<=>?@stABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcduefpghijklmnopqrstuvwxyz{|}~=|,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg=TUV;<=>?@LMNOPQRS|EF789:GHICDbcJKAB012,-./5634\]^_Z[WXY`agdef5o,-./012qr3456789:;<=>?@stABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcduefpghijklmnopqrstuvwxyz{|}~ None!"9;f*Turn a Haskell value into a GraphQL value.v v None!"bf6An error that arises while processing a GraphQL query.Represent an error as human-readable text, primarily intended for developers of GraphQL clients, and secondarily for developers of GraphQL servers.Represent an error as human-readable text, together with reference to a series of locations within a GraphQL query document. Default implementation calls  and provides no locations.GraphQL response.A GraphQL response must:be a map,have a "data" key iff the operation executed9have an "errors" key iff the operation encountered errorsrnot include "data" if operation failed before execution (e.g. syntax errors, validation errors, missing info);not have keys other than "data", "errors", and "extensions"Other interesting things:RDoesn't have to be JSON, but does have to have maps, strings, lists, and null+Can also support bool, int, enum, and float#Value of "extensions" must be a mapb"data" must be null if an error was encountered during execution that prevented a valid response."errors"must be a non-empty listZeach error is a map with "message", optionally "locations" key with list of locations;locations are maps with 1-indexed "line" and "column" keys.w4Construct an object from a list of names and values.#Panic if there are duplicate names.0Make a list of errors containing a single error.xyz{w  xyz{w None !"2349:;DI[fF|A |I is a value that can either be valid or have a non-empty list of errors.}1Type alias for our most common kind of validator.*Errors arising from validating a document.F means there was more than one operation defined with the given name. Ahttps://facebook.github.io/graphql/#sec-Operation-Name-Uniqueness\ means there was more than one operation defined in a document with an anonymous operation. @https://facebook.github.io/graphql/#sec-Lone-Anonymous-Operation^ means that multiple copies of the same argument was given to the same field, directive, etc.J means that there were more than one fragment defined with the same name.r means there was a reference to a fragment in a fragment spread but we couldn't find any fragment with that name.L means there were two copies of the same directive given in the same place. Jhttps://facebook.github.io/graphql/#sec-Directives-Are-Unique-Per-Location9There were multiple variables defined with the same name. means that a fragment definition contains a fragment spread that itself is a fragment definition that contains a fragment spread referring to the first fragment spread.7 means that fragments were defined that weren't used. >https://facebook.github.io/graphql/#sec-Fragments-Must-Be-Used,Variables were defined without being used. :https://facebook.github.io/graphql/#sec-All-Variables-Used,A variable was used without being defined. Ahttps://facebook.github.io/graphql/#sec-All-Variable-Uses-DefinedValue in AST wasn't valid.)Default value in AST contained variables.4Two different names given for the same response key.@Two different sets of arguments given for the same response key.HTwo fields had the same response key, one was a leaf, the other was not.:There's a type condition that's not present in the schema.~7A directive is a way of changing the run-time behaviour;A GraphQL value which might contain some defined variables.6Defines a variable within the context of an operation.See :https://facebook.github.io/graphql/#sec-Language.VariablesThe name of the variableThe type of the variable*An optional default value for the variable7The set of arguments for a given field, directive, etc.Note that the value can be a variable. A validated fragment definition.spreadP indicates whether references to other fragment definitions have been resolved.>An inline fragment, which itself can contain fragment spreads.DA fragment spread that refers to fragments which are known to exist.sA fragment spread that has a valid set of directives, but may or may not refer to a fragment that actually exists.`A field in a selection set, which itself might have children which might have fragment spreads.A GraphQL selection.A field ready to be resolved.A y is the key under which a field appears in a response. If there's an alias, it's the alias, if not, it's the field name.(A selection set, almost fully validated.*Sub-selection sets might not be validated.Type alias for  and  constructors of .A valid query document.Construct this using   on an y. 9The query document contains a single anonymous operation. ?The query document contains multiple uniquely-named operations. 'Get the selection set for an operation. .Turn a parsed document into a known valid one.The document is known to be syntactically valid, as we've got its AST. Here, we confirm that it's semantically valid (modulo types).oResolve all the fragments in a selection set and make sure the names, arguments, and directives are all valid.Runs in , collecting a set of names of , that have been used by this selection set. We do this before validating the values (since that's much easier once everything is in a nice structure and away from the AST), which means we can't yet evaluate directives. (Get the value of an argument in a field.%Get the selection set within a field.Merge two execution fields. Assumes that they are fields for the same response key on the same type (i.e. that they are fields we would actually rationally want to merge).JOnce we know the GraphQL type of the object that a selection set (i.e. a \) is for, we can eliminate all the irrelevant types and present a single, flattened map of  to .MFlatten the selection and group it by response key and then type conditions.Doesn't do any validation at all. Just provides a list of "execution values" which are the possible things that might be executed, depending on the type.hXXX: This is so incredibly complex. No doubt there's a way to simplify, but jml can't see it right now. Get the response key of a field.e"A field s response key is its alias if an alias is provided, and it is otherwise the field s name." 3https://facebook.github.io/graphql/#sec-Field-Alias6Traverse through every fragment spread in a selection.The given function fR is applied to each fragment spread. The rest of the selection remains unchanged..Note that this is essentially a definition of  for  Selection. However, we probably also want to have other kinds of traversals (e.g. for transforming values), so best not to bless one kind with a type class.6Ensure a selection has valid arguments and directives.pResolve the fragment references in a selection, accumulating a set of the fragment names that we have resolved.We're doing a standard depth-first traversal of fragment references, where references are by name, so the set of names can be thought of as a record of visited references.bEnsure fragment definitions are uniquely named, and that their arguments and directives are sane. @https://facebook.github.io/graphql/#sec-Fragment-Name-Uniqueness2Validate a type condition that appears in a query.@Resolve all references to fragments inside fragment definitions.wGuarantees that fragment spreads refer to fragments that have been defined, and that there are no circular references.Returns the resolved fragment definitions and a set of the names of all defined fragments that were referred to by other fragments. This is to be used to guarantee that all defined fragments are used (c.f.  >https://facebook.github.io/graphql/#sec-Fragments-Must-Be-Used). Fhttps://facebook.github.io/graphql/#sec-Fragment-spread-target-defined Mhttps://facebook.github.io/graphql/#sec-Fragment-spreads-must-not-form-cyclesOTurn a set of arguments from the AST into a guaranteed unique set of arguments. ;https://facebook.github.io/graphql/#sec-Argument-Uniqueness3Ensure that a set of variable definitions is valid.1Ensure that a variable definition is a valid one.2Ensure that a default value contains no variables.EGet all the variables referred to in a thing what contains variables.#Make sure all the values are valid.IMake sure each variable has a definition, and each definition a variable.6Ensure that the directives in a given place are valid.Doesn't check to see if directives are defined & doesn't check to see if they are in valid locations, because we don't have access to the schema at this point. Jhttps://facebook.github.io/graphql/#sec-Directives-Are-Unique-Per-Location)Identify all of the validation errors in doc.An empty list means no errors. 2https://facebook.github.io/graphql/#sec-ValidationnReturn a list of all the elements with duplicates. The list of duplicates itself will not contain duplicates.@\xs -> findDuplicates @Int xs == ordNub (findDuplicates @Int xs),Create a map from a list of key-value pairs. Returns a list of duplicates on  if there are duplicates. Throw a single validation error.=Throw multiple validation errors. There must be at least one.RMap over each individual error on a validation. Useful for composing validations.This is somewhat like , but | is not, and cannot be, a /, because the left-hand side is specialized to  NonEmpty e, rather than plain e). Also, whatever function were passed to . would get the whole non-empty list, whereas ! works on one element at a time.mapErrors (+1) (pure "hello")(Validator {runValidator = Right "hello"}mapErrors (+1) (throwE 2))Validator {runValidator = Left (3 :| [])}7mapErrors (+1) (throwErrors (NonEmpty.fromList [3, 5]))*Validator {runValidator = Left (4 :| [6])}The applicative on Validator allows multiple potentially-valid values to be composed, and ensures that *all* validation errors bubble up.z|}~     4The type of the object that the selection set is forJA selection set with type conditions, obtained from the validation processA flattened selection set without type conditions. It's possible that some of the fields in various types are not mergeable, in which case, we'll return a validation error. !"#$%&'/@ABCj     /    j@ABC O|}~      !"#$%&' None!":bf`#A map of variables to their values.In GraphQL the variable values are not part of the query itself, they are instead passed in through a separate channel. Create a `) from this other channel and pass it to f.pGraphQL allows the values of variables to be specified, but doesn't provide a way for doing so in the language.a<An error that occurs while executing a query. Technically,  ResolverError` also falls into the same category, but is separate to help our code be a bit better organized.e(Get an operation from a GraphQL document :https://facebook.github.io/graphql/#sec-Executing-Requests&GetOperation(document, operationName):If {operationName} is {null}:-If {document} contains exactly one operation.1Return the Operation contained in the {document}.:Otherwise produce a query error requiring {operationName}. Otherwise:ELet {operation} be the Operation named {operationName} in {document}.4If {operation} was not found, produce a query error.Return {operation}.f+Substitute variables in a GraphQL document.IOnce this is done, there will be no variables in the document whatsoever. `abcdefg`acdbef`abcdef`abcdefgNone!",69:;DQRTfja! can be converted from a GraphQL  to a Haskell value.The  FromValue instance converts  to the type expected by the handler function. It is the boundary between incoming data and your custom application Haskell types. FromValueA has a generic instance for converting input objects to records.k[Convert an already-parsed value into a Haskell value, generally to be passed to a handler.lLAnything that can be converted to a value and from a value should roundtrip.mThrow an error saying that value does not have the expected type.4Look up a single record field element in the Object.jklmnopqrstuvwxjklmjkklmjkklmnopqrstuvwxNone!",69:;DQRTfyfFor each enum type we need 1) a list of all possible values 2) a way to serialise and 3) deserialise.TODO: Update this comment to explain what a GraphQLEnum is, why you might want an instance, and any laws that apply to method relations.yz{|}~yz{|yzz{{||yzz{{||}~None!"+,69:;DQRTf)Argument operator. Can only be used with .Say we have a CompanyI object that has a field that shows whether someone is an employee, e.g. E type Company { hasEmployee(employeeName: String!): String! }  Then we might represent that as:_type Company = Object "Company" '[] '[Argument "employeeName" Text :> Field "hasEmployee" Bool]8For multiple arguments, simply chain them together with , ending finally with . e.g. A Argument "foo" String :> Argument "bar" Int :> Field "qux" Int ?Turn a non-null type into the optional version of its own type.Hyz{|yzz{{||<88None!"+,29:;<=DEOQRTbfThe  type of a  must be the same for all possible Objects, but each Object has a different type. We unsafeCoerce the return type into an Any, tagging it with the union and the underlying monad for type safety, but we elide the Object type itself. This way we can represent all A types of the Union with a single type and still stay type-safe.RFor unions we need a way to have type-safe, open sum types based on the possible ls of a union. The following closed type family selects one Object from the union and returns the matching   type. If the object o is not a member of " then the user code won't compile.eThis type family is an implementation detail but its TypeError messages are visible at compile time. Run a single  Selection5 over all possible fields (as specified by the type a), returning exactly one . when a field matches, or an error otherwise.7Individual implementations are responsible for calling ] if they haven't matched the field and there are still candidate fields within the handler.}Derive the handler type from the Field/Argument type in a closed type family: We don't want anyone else to extend this ever.7Specify a default value for a type in a GraphQL schema.GraphQL schema can have default values in certain places. For example, arguments to fields can have default values. Because we cannot lift arbitrary values to the type level, we need some way of getting at those values. This typeclass provides the means./To specify a default, implement this typeclass.OThe default implementation is to say that there *is* no default for this type.EdefaultFor returns the value to be used when no value has been given.!Object field separation operator.5Use this to provide handlers for fields of an object.ISay you had the following GraphQL type with "foo" and "bar" fields, e.g. 5 type MyObject { foo: Int! bar: String! } ,You could provide handlers for it like this::m +System.Environmentlet fooHandler = pure 42/let barHandler = System.Environment.getProgName=let myObjectHandler = pure $ fooHandler :<> barHandler :<> ()7There was a problem in the schema. Server-side problem.GCouldn't find the requested field in the object. A client-side problem.JNo value provided for name, and no default specified. Client-side problem.GCould not translate value into Haskell. Probably a client-side problem.6Found validation errors when we tried to merge fields.(Tried to get subselection of leaf field.#Tried to treat an object as a leaf.1Called when the schema expects an input argument name of type a but name has not been provided. Translate a , into a DynamicUnionValue type required by Unionv handlers. This is dynamic, but nevertheless type-safe because we can only tag with types that are part of the union.@Use e.g. like "unionValue @Cat" if you have an object like this:8type Cat = API.Object "Cat" '[] '[API.Field "name" Text]*and then use `unionValue @Cat (pure (pure Felix ))`. See `examples/UnionExample.hs` for more code.E388None !"OTbf 9Errors that can happen while processing a query document.Failed to parse.Parsed, but failed validation.See  2https://facebook.github.io/graphql/#sec-Validation for more details.'Validated, but failed during execution.Error in the schema."Got a value that wasn't an object.Execute a GraphQL query.Create a GraphQL schema.Interpet a GraphQL query.'Compiles then executes a GraphQL query.%Interpret an anonymous GraphQL query.5Anonymous queries have no name and take no variables.+Turn some text into a valid query document.Parse a query document.=Get an operation from a query document ready to be processed.THandler for the query. This links the query to the code you've written to handle it.+A validated query document. Build one with .An optional name. If 4, then executes the only operation in the query. If Just "something"(, executes the query named @"something".=Values for variables defined in the query document. A map of Variable to .!The outcome of running the query.THandler for the query. This links the query to the code you've written to handle it.?The text of a query document. Will be parsed and then executed.>An optional name for the operation within document to run. If 1, execute the only operation in the document. If Just "something"&, execute the query or mutation named  "something".=Values for variables defined in the query document. A map of Variable to .!The outcome of running the query. Handler for the anonymous query.WThe text of the anonymous query. Should defined only a single, unnamed query operation. The result of running the query.d`d`  !"#$%&'()*+,-./011223344556677889::;<<=>?@ABCDEFGHHIIJKLMNNOPPQQRRSSTUVWXYZ[\]^^__``aabccdefghiijjklmnoopqrsstuvwxyz{|}~P\[ZYXWVU               2 2 3 3 4 4      ! 6 6 7 7 " " : : ; < < = > ? @ A B C D J # $ E F G H H % K L M & ' ( ( ) * + , - . / 0 1 2 3 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 z { | } ~                                           c   h h  s                                                                                           ac!"#$$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNNOOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstu*vwxyz{|}~|}|uP O  1 1 5 5 )           ^ _ `     l m    |              |   ||       ^ _ `   e f g c                 !"#$%&'()*+,-./0123456Q789(graphql-api-0.1.1-KSX3TpyT1ds4NYDEPDAA48GraphQL.Internal.Syntax.TokensGraphQL.Internal.OrderedMapGraphQL.Internal.ArbitraryGraphQL.Internal.Syntax.ASTGraphQL.Internal.NameGraphQL.Internal.Syntax.EncoderGraphQL.Internal.Syntax.Parser GraphQL.ValueGraphQL.Internal.SchemaGraphQL.Value.ToValueGraphQL.Internal.OutputGraphQL.Internal.ValidationGraphQL.Internal.ExecutionGraphQL.Value.FromValueGraphQL.API.Enum GraphQL.APIGraphQL.ResolverGraphQLVariableDefinitionASTValuetok whiteSpace OrderedMapkeystoMaptoList genOrderedMapempty singletonlookupvaluesunions unionWith unionsWith unionWithM unionsWithM catMaybes orderedMap$fArbitraryOrderedMap$fFunctorOrderedMap$fTraversableOrderedMap$fFoldableOrderedMap$fEqOrderedMap$fOrdOrderedMap$fShowOrderedMap arbitraryTextarbitraryNonEmptyTypeExtensionDefinitionInputObjectTypeDefinitionEnumValueDefinitionEnumTypeDefinitionScalarTypeDefinitionUnionTypeDefinitionInterfaceTypeDefinitionInputValueDefinitionArgumentsDefinitionFieldDefinition InterfacesObjectTypeDefinitionTypeDefinitionTypeDefinitionObjectTypeDefinitionInterfaceTypeDefinitionUnionTypeDefinitionScalarTypeDefinitionEnumTypeDefinitionInputObjectTypeDefinitionTypeExtension NonNullTypeNonNullTypeNamedNonNullTypeListListType NamedTypeType TypeNamedTypeList TypeNonNull Directive DefaultValue ObjectField ObjectValue ListValue StringValue ValueVariableValueInt ValueFloat ValueBoolean ValueString ValueEnum ValueList ValueObject ValueNull TypeConditionFragmentDefinitionInlineFragmentFragmentSpreadArgumentAliasField SelectionSelectionFieldSelectionFragmentSpreadSelectionInlineFragment SelectionSetVariableNodeOperationDefinitionQueryMutationAnonymousQuerySchemaDocument DefinitionDefinitionOperationDefinitionFragment QueryDocumentgetDefinitionsNameunName nameParser getNodeName$fArbitraryObjectField$fArbitraryObjectValue$fArbitraryListValue$fArbitraryStringValue$fArbitraryValue$fArbitraryVariable$fArbitraryName $fToJSONName$fEqName $fOrdName $fShowName $fEqVariable $fOrdVariable$fShowVariable$fEqStringValue$fShowStringValue$fEqObjectField$fShowObjectField $fEqValue $fShowValue$fEqObjectValue$fShowObjectValue $fEqListValue$fShowListValue $fEqArgument$fShowArgument $fEqDirective$fShowDirective$fEqFragmentSpread$fShowFragmentSpread $fEqNamedType$fOrdNamedType$fShowNamedType$fEqInlineFragment$fShowInlineFragment $fEqSelection$fShowSelection $fEqField $fShowField$fEqFragmentDefinition$fShowFragmentDefinition$fEqNonNullType$fOrdNonNullType$fShowNonNullType $fEqListType $fOrdListType$fShowListType$fEqType $fOrdType $fShowType$fEqVariableDefinition$fShowVariableDefinition$fEqNode $fShowNode$fEqOperationDefinition$fShowOperationDefinition$fEqDefinition$fShowDefinition$fEqQueryDocument$fShowQueryDocument$fEqInputValueDefinition$fShowInputValueDefinition$fEqFieldDefinition$fShowFieldDefinition$fEqObjectTypeDefinition$fShowObjectTypeDefinition$fEqInterfaceTypeDefinition$fShowInterfaceTypeDefinition$fEqUnionTypeDefinition$fShowUnionTypeDefinition$fEqScalarTypeDefinition$fShowScalarTypeDefinition$fEqEnumValueDefinition$fShowEnumValueDefinition$fEqEnumTypeDefinition$fShowEnumTypeDefinition$fEqInputObjectTypeDefinition$fShowInputObjectTypeDefinition$fEqTypeExtensionDefinition$fShowTypeExtensionDefinition$fEqTypeDefinition$fShowTypeDefinition$fEqSchemaDocument$fShowSchemaDocumentHasNamegetName NameErrormakeNamenameFromSymbolunsafeMakeName $fEqNameError$fShowNameError queryDocumentschemaDocumentvalue ObjectField'ObjectObject'ListList'String ConstScalarUnresolvedVariableValueValue' ValueScalar' ValueList' ValueObject'toObject objectFields makeObjectobjectFromOrderedMapobjectFromList unionObjectsastToVariableValue valueToASTvariableValueToAST$fToJSONObject'$fArbitraryObjectField'$fArbitraryObject'$fTraversableObject'$fFoldableObject' $fToJSONList'$fArbitraryList'$fTraversableList'$fFoldableList'$fToJSONString$fArbitraryString$fArbitraryConstScalar$fToJSONConstScalar$fArbitraryValue'$fToJSONValue'$fTraversableValue'$fFoldableValue' $fEqString $fOrdString $fShowString$fEqConstScalar$fOrdConstScalar$fShowConstScalar $fEqObject' $fOrdObject' $fShowObject'$fFunctorObject' $fEqValue' $fOrdValue' $fShowValue'$fFunctorValue' $fEqList' $fOrdList' $fShowList'$fFunctorList'$fEqObjectField'$fOrdObjectField'$fShowObjectField'$fFunctorObjectField'InputTypeDefinitionInputTypeDefinitionObjectInputTypeDefinitionScalarInputTypeDefinitionEnum InputTypeDefinedInputTypeBuiltinInputTypeInputObjectFieldDefinitionBuiltinGIntGBoolGStringGFloatGIDArgumentDefinition DefinedType BuiltinType AnnotatedType DefinesTypesgetDefinedTypes NonEmptyListSchema makeSchema lookupTypedoesFragmentTypeApply$fHasNameInputTypeDefinition$fHasNameInputType $fHasNameTypeExtensionDefinition#$fHasNameInputObjectFieldDefinition"$fHasNameInputObjectTypeDefinition$fHasNameEnumValueDefinition $fDefinesTypesEnumTypeDefinition$fHasNameEnumTypeDefinition$fHasNameBuiltin"$fDefinesTypesScalarTypeDefinition$fHasNameScalarTypeDefinition!$fDefinesTypesUnionTypeDefinition$fHasNameUnionTypeDefinition%$fDefinesTypesInterfaceTypeDefinition $fHasNameInterfaceTypeDefinition$fHasNameArgumentDefinition$fDefinesTypesFieldDefinition$fHasNameFieldDefinition"$fDefinesTypesObjectTypeDefinition$fHasNameObjectTypeDefinition$fDefinesTypesTypeDefinition$fHasNameTypeDefinition $fHasNameType$fDefinesTypesType$fHasNameAnnotatedType$fEqNonEmptyList$fOrdNonEmptyList$fShowNonEmptyList$fFunctorNonEmptyList$fFoldableNonEmptyList$fEqAnnotatedType$fOrdAnnotatedType$fShowAnnotatedType$fOrdScalarTypeDefinition $fEqBuiltin $fOrdBuiltin $fShowBuiltin$fOrdEnumValueDefinition$fOrdEnumTypeDefinition$fEqInputObjectFieldDefinition$fOrdInputObjectFieldDefinition $fShowInputObjectFieldDefinition $fEqInputType$fOrdInputType$fShowInputType$fEqInputTypeDefinition$fOrdInputTypeDefinition$fShowInputTypeDefinition$fOrdInputObjectTypeDefinition$fEqArgumentDefinition$fOrdArgumentDefinition$fShowArgumentDefinition$fOrdFieldDefinition$fOrdTypeDefinition$fOrdTypeExtensionDefinition$fOrdObjectTypeDefinition$fOrdInterfaceTypeDefinition$fOrdUnionTypeDefinition $fEqSchema $fOrdSchema $fShowSchemaToValuetoValue$fToValueObject'$fToValueList' $fToValueText$fToValueString$fToValueDouble$fToValueInt32 $fToValueBool$fToValueNonEmpty$fToValueMaybe $fToValue[]$fToValueValue' GraphQLError formatErrortoErrorErrorErrorsResponseSuccessPreExecutionFailureExecutionFailurePartialSuccess singleError$fGraphQLErrorNameError$fToValueLocation$fToValueError$fToJSONResponse$fToValueResponse $fEqLocation $fOrdLocation$fShowLocation $fEqError $fOrdError $fShowError $fEqResponse $fOrdResponse$fShowResponseValidationErrorsValidationErrorDuplicateOperationMixedAnonymousOperationsDuplicateArgumentDuplicateFragmentDefinitionNoSuchFragmentDuplicateDirectiveDuplicateVariableDefinitionCircularFragmentSpreadUnusedFragmentsUnusedVariablesUndefinedVariable InvalidValueInvalidDefaultValueMismatchedNamesMismatchedArgumentsIncompatibleFieldsTypeConditionNotFound VariableValuevariable variableType defaultValue ResponseKeySelectionSetByType OperationLoneAnonymousOperationMultipleOperationsgetSelectionSetvalidatelookupArgumentgetSubSelectionSetgetSelectionSetForTypegetResponseKey getErrorsfindDuplicates$fApplicativeValidator$fGraphQLErrorValidationError$fTraversableFragmentDefinition$fFoldableFragmentDefinition$fFunctorFragmentDefinition$fTraversableInlineFragment$fFoldableInlineFragment$fFunctorInlineFragment$fTraversableFragmentSpread$fFoldableFragmentSpread$fFunctorFragmentSpread%$fTraversableUnresolvedFragmentSpread"$fFoldableUnresolvedFragmentSpread$fTraversableField'$fFoldableField'$fFunctorField'$fHasNameField'$fHasNameField$fTraversableOperation$fFoldableOperation$fFunctorOperation $fEqArguments$fOrdArguments$fShowArguments$fFunctorArguments$fFoldableArguments$fTraversableArguments $fOrdField$fFunctorField$fFoldableField$fTraversableField$fEqSelectionSetByType$fOrdSelectionSetByType$fShowSelectionSetByType$fFunctorSelectionSetByType$fFoldableSelectionSetByType$fTraversableSelectionSetByType$fEqSelectionSet$fOrdSelectionSet$fShowSelectionSet$fOrdVariableDefinition$fEqDirectives$fOrdDirectives$fShowDirectives$fFoldableDirectives$fFunctorDirectives$fTraversableDirectives$fEqUnresolvedFragmentSpread$fShowUnresolvedFragmentSpread!$fFunctorUnresolvedFragmentSpread $fEqField' $fShowField'$fEqSelection'$fShowSelection'$fFunctorSelection'$fFoldableSelection'$fTraversableSelection' $fEqOperation$fShowOperation$fEqValidationError$fShowValidationError $fEqValidator$fShowValidator$fFunctorValidator$fMonadValidatorVariableValuesExecutionError MissingValueNoSuchOperationNoAnonymousOperation getOperationsubstituteVariables$fGraphQLErrorExecutionError$fEqExecutionError$fShowExecutionError FromValue fromValueprop_roundtripValue wrongType$fGenericFromValueM1$fGenericFromValueM10$fGenericFromValue:*:$fGenericFromValueM11$fFromValueMaybe$fFromValueNonEmpty $fFromValue[]$fFromValueText$fFromValueBool$fFromValueDouble$fFromValueInt32 GraphQLEnum enumValues enumFromValue enumToValue$fGenericEnumValues:+:$fGenericEnumValuesM1$fGenericEnumValuesM10$fGenericEnumValues:+:0$fGenericEnumValuesM11HasAnnotatedInputTypegetAnnotatedInputTypeHasAnnotatedTypegetAnnotatedTypegetArgumentDefinitiongetInterfaceDefinitiongetFieldDefinitionHasObjectDefinition getDefinitionDefaultArgument InterfaceUnionEnum:>&$fGenericInputObjectFieldDefinitionsM1'$fGenericInputObjectFieldDefinitions:*:$fGenericAnnotatedInputTypeM1$fHasAnnotatedInputTypeEnum$fHasAnnotatedInputTypeList$fHasAnnotatedInputTypeFloat$fHasAnnotatedInputTypeDouble$fHasAnnotatedInputTypeText$fHasAnnotatedInputTypeBool$fHasAnnotatedInputTypeInt32$fHasAnnotatedInputTypeInt$fHasAnnotatedInputTypeMaybe$fHasAnnotatedTypeTYPEInteger$fHasAnnotatedTypeTYPEUnion$fHasAnnotatedTypeTYPEEnum$fHasAnnotatedTypeTYPEList$fHasAnnotatedTypeTYPEFloat$fHasAnnotatedTypeTYPEDouble$fHasAnnotatedTypeTYPEText$fHasAnnotatedTypeTYPEBool$fHasAnnotatedTypeTYPEInt32$fHasAnnotatedTypeTYPEInt$fHasAnnotatedTypeTYPEMaybe$fHasObjectDefinitionTYPEObject$fHasFieldDefinitionTYPE:>#$fHasArgumentDefinitionTYPEArgument$fHasFieldDefinitionTYPEField$fHasAnnotatedTypeTYPEObject $fHasFieldDefinitionTYPEArgument%$fHasInterfaceDefinitionTYPEInterface$fHasInterfaceDefinitions[][]$fHasInterfaceDefinitions[]:'$fUnionTypeObjectTypeDefinitionList[][]&$fUnionTypeObjectTypeDefinitionList[]:$fHasFieldDefinitions[][]$fHasFieldDefinitions[]: Defaultable defaultFor HasResolverHandlerresolveResult:<> ResolverError SchemaErrorFieldNotFoundError ValueMissingSubSelectionOnLeafMissingSelectionSet unionValue$fHasResolverTYPEmUnion$fRunUnion[]munion[]$fRunUnion[]munion:$fHasResolverTYPEmObject$fRunFieldsm:>$fRunFieldsmField$fRunFieldsm:<>!$fBuildFieldResolvermEnumArgument"$fBuildFieldResolvermPlainArgument $fBuildFieldResolvermJustHandler$fHasResolverTYPEmMaybe$fHasResolverTYPEmEnum$fHasResolverTYPEmList$fHasResolverTYPEmBool$fHasResolverTYPEmText$fHasResolverTYPEmDouble$fHasResolverTYPEmInt32$fDefaultableMaybe$fDefaultableText$fDefaultableBool$fDefaultableDouble$fDefaultableInt32$fApplicativeResult$fGraphQLErrorResolverError$fShowResolverError$fEqResolverError $fShowResult$fFunctorResult $fEqResult QueryError executeQueryinterpretQueryinterpretAnonymousQuery compileQuery$fGraphQLErrorQueryError$fEqQueryError$fShowQueryErrorbaseGHC.BaseNothingMaybeliftMM#text-1.2.2.1-9Yh8rJoh8fO2JMLWffT3QsData.Text.InternalTextData.List.NonEmptyNonEmptyghc-prim GHC.TypesSymbol definitionoperationDefinitionnodevariableDefinitionsvariableDefinition selectionSet selectionfield argumentsargumentfragmentSpreadinlineFragmentfragmentDefinition booleanValue stringValue listValue objectValue objectField directives directivetype_ namedTypelistType nonNullTypetypeDefinitionobjectTypeDefinition interfacesfieldDefinitionsfieldDefinitionargumentsDefinitioninterfaceTypeDefinitionunionTypeDefinition unionMembersscalarTypeDefinitionenumTypeDefinitionenumValueDefinitioninputObjectTypeDefinitioninputValueDefinitionsinputValueDefinitiontypeExtensionDefinitionspacedbetweenparensbracketsbracesspaces parensCommasbracketsCommas bracesCommasoptemptyalias typeConditionenumValueDefinitionsUnresolvedVariableScalargenValueconstScalarToAST variableToAST astToScalar genObject astToValue' valueToAST'ConstInt ConstFloat ConstBoolean ConstString ConstEnum ConstNullmakeListunsafeMakeObjectColumnLineLocation Validator Validation Directives ArgumentsUnresolvedFragmentSpreadField' Selection' OperationTypevalidateSelectionSettransformers-0.5.2.0Control.Monad.Trans.State.LazyStateT mergeFieldsgroupByResponseKeytraverseFragmentSpreadsData.Traversable TraversablevalidateSelectionresolveSelectionvalidateFragmentDefinitionsvalidateTypeConditionresolveFragmentDefinitionsvalidateArgumentsvalidateVariableDefinitionsvalidateVariableDefinitionvalidateDefaultValue getVariablesvalidateValuesresolveVariablesvalidateDirectivesmakeMap Data.EitherLeftthrowE throwErrors mapErrorsData.Bifunctorfirst Bifunctor runValidatorVariableDefinitions FragmentsnamesubSelectionSet OperationsvalidateOperationsvalidateOperationgetDefinedVariablesemptyVariableDefinitionsemptyDirectivesreplaceVariablegetValueGenericFromValuegenericFromValueGenericEnumValuesgenericEnumValuesgenericEnumFromValuegenericEnumToValueinvalidEnumName dropNonNull"GenericInputObjectFieldDefinitions%genericGetInputObjectFieldDefinitionsGenericAnnotatedInputTypegenericGetAnnotatedInputTypeHasArgumentDefinitionHasInterfaceDefinitionHasInterfaceDefinitionsgetInterfaceDefinitions!UnionTypeObjectTypeDefinitionList!getUnionTypeObjectTypeDefinitionsHasFieldDefinitionsgetFieldDefinitionsHasFieldDefinitioncons builtinTypebuiltinInputTypeDynamicUnionValue TypeIndex runFields FieldHandler valueMissingRunUnionrunUnion_label_value RunFieldsRunFieldsHandler RunFieldsTypeBuildFieldResolverbuildFieldResolverFieldResolverDispatchType PlainArgument EnumArgument JustHandler FieldNameResolveFieldResultaggregateResultsok resolveField symbolTextextractUnionValue ParseErrorNonObjectResult parseQuery