!:       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                          ! " # $ % & ' ( ) * + , - . /01 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 { | } ~                                                                                                          !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~)QuickCheck instances to help with testingSafe"#SXk) graphql-apiGenerate arbitrary . graphql-apiGenerate an arbitrary  list.NData structure for mapping keys to values while preserving order of appearanceSafe"#SXkH graphql-apiAGet the list of keys from an ordered map, in order of appearance..This list is guaranteed to have no duplicates. graphql-api@Convert an ordered map to a regular map, losing insertion order. graphql-apiConvert 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) graphql-api>Generate an ordered map with the given key & value generators. graphql-apiThe empty OrderedMap. O(1) graphql-api1Create an ordered map containing a single entry. O(1)  graphql-apiFind a value in an ordered map.O(log n)  graphql-api<Get the values from an ordered map, in order of appearance.  O(n log n)  graphql-api$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.  graphql-apicAppend the second ordered map to the first, combining any shared elements with the given function.  graphql-apizAppend together a list of ordered maps, preserving ordering of keys. Combine any shared elements with the given function. graphql-apiTake 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. graphql-apiqTake a list of ordered maps and append them together. Any shared elements are combined using the given function. graphql-apiTake an ordered map with  . values and return the same map with all the   values removed. graphql-api%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.    Basic tokenising used by parserSafe"#kJ Representation of GraphQL names.None "#.HSXkY* graphql-apiXTypes 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. graphql-apiGet the name of the object. graphql-apiAn invalid name. graphql-apiA name in GraphQL. -https://facebook.github.io/graphql/#sec-Names" graphql-api Create a ), panicking if the given text is invalid.Prefer # to this in all cases.unsafeMakeName "foo"Name {unName = "foo"}# graphql-api Create a .Names must match the regex [_A-Za-z][_0-9A-Za-z]*6. If the given text does not match, return NameError.makeName "foo"Right (Name {unName = "foo"})makeName "9-bar"Left (NameError "9-bar")$ graphql-api Parser for .% graphql-apiConvert a type-level   into a GraphQL .  !"#$%  !#%$"The GraphQL ASTNone "#.SXk^ graphql-apiA - is a document that defines a GraphQL schema. 3https://facebook.github.io/graphql/#sec-Type-System graphql-apiA # is something a user might send us. ?https://facebook.github.io/graphql/#sec-Language.Query-Document graphql-apiGet the name of the given S.a./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSVTUWXYZ[\]^_`abkjhdefgiclmnopqrstuvwxyz{|}~a}~|xyz{vwustqropmnlbkjhdefgic`a^_\]Z[YWXSVTUQROPLMNDEFGHIJKBCA?@><=:;8967452301./Parse text into GraphQL ASTsNone"#>kc  graphql-apiParser for a schema document. Turn GraphQL ASTs into textNone"#kc Literal GraphQL valuesNone"#4=>?HMSVX_gk graphql-api3A field of an object that has a non-variable value. graphql-api8A GraphQL object that contains only non-variable values. graphql-apiA 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. graphql-api0A 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.  graphql-api^A value which contains no other values, and might be a variable that might lack a definition. graphql-api4A non-variable value which contains no other values. graphql-apicA 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. graphql-api,A GraphQL value which contains no variables. graphql-apiA 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).  graphql-api2Generate an arbitrary value, with objects at most n levels deep. graphql-api5If a value is an object, return just that. Otherwise Nothing. graphql-api)Convert a constant scalar to an AST.Value graphql-api)Convert a variable scalar to an AST.Value graphql-apiBConvert a value from the AST into a variable scalar, presuming it is a scalar. graphql-api8Generate an arbitrary object to the given maximum depth. graphql-api,Make an object from a list of object fields. graphql-api#Make an object from an ordered map. graphql-api4Create an object from a list of (name, value) pairs. graphql-api*Convert an AST value into a literal value.YThis is a stop-gap until we have proper conversion of user queries into canonical forms. graphql-api)Convert an AST value to a variable value.VWill fail if the AST value contains duplicate object fields, or is otherwise invalid. graphql-api Convert a value to an AST value. graphql-api)Convert a variable value to an AST value. graphql-api*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.  graphql-api#Generate an arbitrary scalar value.) !#* !# 8Turn domain-specific Haskell values into GraphQL values.None"#=?kV/ graphql-api*Turn a Haskell value into a GraphQL value./0/0 8Convert GraphQL values to domain-specific Haskell valuesNone"#.8=>?HUVXkI< graphql-apia! 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.= graphql-api[Convert an already-parsed value into a Haskell value, generally to be passed to a handler.> graphql-apiLAnything that can be converted to a value and from a value should roundtrip.? graphql-apiThrow an error saying that value does not have the expected type. graphql-api4Look up a single record field element in the Object.<=>?<=>?Literal GraphQL valuesNone"#gk"- !#/0<=. !#/0<= DFully realized GraphQL schema type system at the Haskell value levelNone"#k graphql-apiDA 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 f() and fields within input objects (see RH) can have default values. These are allowed to be any kind of literal.Z graphql-api"Types that are built into GraphQL.7The GraphQL spec refers to these as "[scalars](https:/facebook.github.iographql/#sec-Scalars)".[ graphql-api,A signed 32 bit numeric non fractional value\ graphql-api True or false] graphql-api5Textual data represented as UTF-8 character sequences^ graphql-api:Signed double precision fractional values as specified by 1https://en.wikipedia.org/wiki/IEEE_floating_pointIEEE 754_ graphql-apiNA unique identifier, often used to refetch an object or as the key for a cache graphql-api@A thing that defines types. Excludes definitions of input types. graphql-apiGet 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. graphql-apiAn 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. graphql-api%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. graphql-api+Create an empty schema for testing purpose. graphql-api0Find the type with the given name in the schema. graphql-api%Get the type that is being annotated. graphql-api: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.  graphql-apiConvert the given m to an K if it's a valid K (because K is a subset of m) see Fhttp://facebook.github.io/graphql/June2018/#sec-Input-and-Output-Types graphql-api Create a Z type from a qMostly used for the AST validation theobat: There's probably a better way to do it but can't find it right now  graphql-apiSimple translation between AST annotation types and  annotation typesAST type annotations do not need any validation. GraphQL annotations are semantic decorations around type names to indicate type composition (list/non null).AKLMNOQPRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~AuvwZ[\]^_mnopqrstfgVWXYhijdeklbc`aOQPKLMNTURS}~{|xyzHow we encode GraphQL responsesNone"#gk graphql-api6An error that arises while processing a GraphQL query. graphql-apiRepresent an error as human-readable text, primarily intended for developers of GraphQL clients, and secondarily for developers of GraphQL servers. graphql-apiRepresent 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-apiGraphQL 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. graphql-api4Construct an object from a list of names and values.#Panic if there are duplicate names. graphql-api0Make a list of errors containing a single error.  @Transform GraphQL query documents from AST into valid structuresNone "#456=>?HM_kL graphql-apiA I is a value that can either be valid or have a non-empty list of errors. graphql-api1Type alias for our most common kind of validator. graphql-api*Errors arising from validating a document. graphql-apiF means there was more than one operation defined with the given name. Ahttps://facebook.github.io/graphql/#sec-Operation-Name-Uniqueness graphql-api\ means there was more than one operation defined in a document with an anonymous operation. @https://facebook.github.io/graphql/#sec-Lone-Anonymous-Operation graphql-api^ means that multiple copies of the same argument was given to the same field, directive, etc. graphql-apiJ means that there were more than one fragment defined with the same name. graphql-apir means there was a reference to a fragment in a fragment spread but we couldn't find any fragment with that name. graphql-apiL means there were two copies of the same directive given in the same place. Jhttps://facebook.github.io/graphql/#sec-Directives-Are-Unique-Per-Location graphql-api9There were multiple variables defined with the same name. graphql-api 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. graphql-api7 means that fragments were defined that weren't used. >https://facebook.github.io/graphql/#sec-Fragments-Must-Be-Used graphql-api,Variables were defined without being used. :https://facebook.github.io/graphql/#sec-All-Variables-Used  graphql-api,A variable was used without being defined. Ahttps://facebook.github.io/graphql/#sec-All-Variable-Uses-Defined  graphql-apiValue in AST wasn't valid.  graphql-api)Default value in AST contained variables.  graphql-api4Two different names given for the same response key.  graphql-api@Two different sets of arguments given for the same response key. graphql-apiHTwo fields had the same response key, one was a leaf, the other was not. graphql-api:There's a type condition that's not present in the schema. graphql-api9There's a variable type that's not present in the schema. graphql-api/A variable was defined with a non input type. Ihttp://facebook.github.io/graphql/June2018/#sec-Variables-Are-Input-Types graphql-api7A directive is a way of changing the run-time behaviour graphql-api;A GraphQL value which might contain some defined variables. graphql-api6Defines a variable within the context of an operation.See :https://facebook.github.io/graphql/#sec-Language.Variables graphql-apiThe name of the variable graphql-apiThe type of the variable graphql-api*An optional default value for the variable graphql-api7The set of arguments for a given field, directive, etc.Note that the value can be a variable. graphql-api A validated fragment definition.spreadP indicates whether references to other fragment definitions have been resolved. graphql-api>An inline fragment, which itself can contain fragment spreads. graphql-apiDA fragment spread that refers to fragments which are known to exist. graphql-apisA fragment spread that has a valid set of directives, but may or may not refer to a fragment that actually exists.  graphql-api`A field in a selection set, which itself might have children which might have fragment spreads.! graphql-apiA GraphQL selection. graphql-apiA field ready to be resolved. graphql-apiA 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. graphql-api(A selection set, almost fully validated.*Sub-selection sets might not be validated." graphql-apiType alias for # and $ constructors of . graphql-apiA valid query document.Construct this using " on an . graphql-api9The query document contains a single anonymous operation.  graphql-api?The query document contains multiple uniquely-named operations.! graphql-api'Get the selection set for an operation." graphql-api.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).% graphql-apioResolve 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.# graphql-api(Get the value of an argument in a field.$ graphql-api%Get the selection set within a field.' graphql-apiMerge 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).% graphql-apiJOnce 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 .( graphql-apiMFlatten 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.& graphql-api 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-Alias) graphql-api6Traverse 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.+ graphql-api6Ensure a selection has valid arguments and directives., graphql-apipResolve 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.- graphql-apibEnsure fragment definitions are uniquely named, and that their arguments and directives are sane. @https://facebook.github.io/graphql/#sec-Fragment-Name-Uniqueness. graphql-api2Validate a type condition that appears in a query./ graphql-api@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-cycles0 graphql-apiOTurn a set of arguments from the AST into a guaranteed unique set of arguments. ;https://facebook.github.io/graphql/#sec-Argument-Uniqueness1 graphql-api3Ensure that a set of variable definitions is valid.2 graphql-api1Ensure that a variable definition is a valid one.3 graphql-apiEEnsure that a variable has a correct type declaration given a schema.4 graphql-apiCValidate a variable type which has a type definition in the schema.5 graphql-api\Validate a variable type which has no type definition (either builtin or not in the schema).6 graphql-api2Ensure that a default value contains no variables.7 graphql-apiEGet all the variables referred to in a thing what contains variables.8 graphql-api#Make sure all the values are valid.9 graphql-apiIMake sure each variable has a definition, and each definition a variable.: graphql-api6Ensure 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' graphql-api)Identify all of the validation errors in doc.An empty list means no errors. 2https://facebook.github.io/graphql/#sec-Validation( graphql-apinReturn 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); graphql-api,Create a map from a list of key-value pairs. Returns a list of duplicates on < if there are duplicates.) graphql-apilUtility function for tests, format ErrorTypes to their text representation returns a list of error messages= graphql-api Throw a single validation error.> graphql-api=Throw multiple validation errors. There must be at least one.? graphql-apiRMap over each individual error on a validation. Useful for composing validations.This is somewhat like @, but  is not, and cannot be, a 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])}> graphql-apiThe applicative on Validator allows multiple potentially-valid values to be composed, and ensures that *all* validation errors bubble up.% graphql-api4The type of the object that the selection set is for graphql-apiJA selection set with type conditions, obtained from the validation process graphql-apiA 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.2SVTU}      !"#$%&'()2      "'!}SVTU%#$&()'Define GraphQL Enums with Haskell typesNone"#.8=>?HUVXky graphql-apifFor 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{|*Define a GraphQL schema with Haskell typesNone"#-.8=>?HUVXk graphql-api7Specify 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. graphql-apiEdefaultFor returns the value to be used when no value has been given. graphql-api*The type-level schema was somehow invalid. graphql-api)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 B graphql-api?Turn a non-null type into the optional version of its own type.yz{|yz{|88&Implement handlers for GraphQL schemasNone"#,-.4=>?@AHISUVX_gkԿC graphql-apiThe  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.D graphql-apiRFor 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.E graphql-api 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 E] if they haven't matched the field and there are still candidate fields within the handler.F graphql-api}Derive the handler type from the Field/Argument type in a closed type family: We don't want anyone else to extend this ever.G graphql-apiSThe result of a handler is either text errors generated by the handler or a value. graphql-api!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 :<> () graphql-api7There was a problem in the schema. Server-side problem. graphql-apiGCouldn't find the requested field in the object. A client-side problem. graphql-apiJNo value provided for name, and no default specified. Client-side problem. graphql-apiGCould not translate value into Haskell. Probably a client-side problem. graphql-api6Found validation errors when we tried to merge fields. graphql-api(Tried to get subselection of leaf field. graphql-api#Tried to treat an object as a leaf. graphql-apiError from handler graphql-apiO is a convenience function for a Handler that is returning the expected value. graphql-apis is a convenience function for a Handler that has encountered an error and is unable to return the expected value.H graphql-api1Called when the schema expects an input argument name of type a but name has not been provided. graphql-api 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.88&Implement handlers for GraphQL schemasNone"#k~*Define a GraphQL schema with Haskell typesNone"#k&yz{|yz{|3Implement the "Execution" part of the GraphQL spec.None"#>gk graphql-api#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 .pGraphQL allows the values of variables to be specified, but doesn't provide a way for doing so in the language. graphql-api<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. graphql-api(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}. graphql-api+Substitute variables in a GraphQL document.IOnce this is done, there will be no variables in the document whatsoever.None"#>HSVXgk   graphql-api9Errors that can happen while processing a query document.I graphql-apiFailed to parse.J graphql-apiParsed, but failed validation.See  2https://facebook.github.io/graphql/#sec-Validation for more details.K graphql-api'Validated, but failed during execution.L graphql-apiError in the schema.M graphql-api"Got a value that wasn't an object. graphql-apiExecute a GraphQL query. graphql-apiCreate a GraphQL schema. graphql-apiInterpet a GraphQL query.'Compiles then executes a GraphQL query. graphql-api%Interpret an anonymous GraphQL query.5Anonymous queries have no name and take no variables. graphql-api+Turn some text into a valid query document.N graphql-apiParse a query document.O graphql-api=Get an operation from a query document ready to be processed. graphql-apiTHandler for the query. This links the query to the code you've written to handle it. graphql-api+A validated query document. Build one with . graphql-apiAn optional name. If  4, then executes the only operation in the query. If Just "something"(, executes the query named @"something". graphql-api=Values for variables defined in the query document. A map of Variable to . graphql-api!The outcome of running the query. graphql-apiTHandler for the query. This links the query to the code you've written to handle it. graphql-api?The text of a query document. Will be parsed and then executed. graphql-api>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". graphql-api=Values for variables defined in the query document. A map of Variable to . graphql-api!The outcome of running the query. graphql-api Handler for the anonymous query. graphql-apiWThe text of the anonymous query. Should defined only a single, unnamed query operation. graphql-api The result of running the query.Safe"#k PQRSTUVWX !"#$%&'()*+,-./012345677889:;<=>?@ABCDEFFGGHHIIJJKKLLMMNOOPQQRSTUVWXYZ[\]]^^_`abccdeeffgghhijklmnopqrssttuuvvwxxyz{|}~~ e                 e q p o n m l k j                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < < G G H H I I = > ? @ A B J J K K L L C C O O P Q Q R S T U V W X Y _ D E Z [ \ ] ] F ` a b 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 { | } ~            x}}      !"7#$vx%&'((=)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYYZZ["\]^_`abcdefghijklmnopqrstuvwxyz{|}~J          d stu~"(graphql-api-0.4.0-DBp94HGsSZl390cGoqOlFvGraphQL.Internal.ArbitraryGraphQL.Internal.OrderedMapGraphQL.Internal.Syntax.TokensGraphQL.Internal.Name GraphQL.ValueGraphQL.Internal.Syntax.ASTGraphQL.Internal.ValidationGraphQL.Internal.Syntax.ParserGraphQL.Internal.Syntax.EncoderGraphQL.Internal.ValueGraphQL.Internal.Value.ToValue GraphQL.Internal.Value.FromValueGraphQL.Internal.SchemaGraphQLGraphQL.Internal.OutputGraphQL.Internal.Execution GraphQL.APIGraphQL.Internal.API.EnumGraphQL.Internal.APIGraphQL.ResolverGraphQL.Internal.ResolverVariableDefinitionASTValuePaths_graphql_api arbitraryTextarbitraryNonEmpty OrderedMapkeystoMaptoList genOrderedMapempty singletonlookupvaluesunions unionWith unionsWith unionWithM unionsWithM catMaybes orderedMap$fArbitraryOrderedMap$fFunctorOrderedMap$fTraversableOrderedMap$fFoldableOrderedMap$fEqOrderedMap$fOrdOrderedMap$fShowOrderedMaptok whiteSpaceHasNamegetName NameErrorNameunNameunsafeMakeNamemakeName nameParsernameFromSymbol$fArbitraryName $fToJSONName$fIsStringName$fEqName $fOrdName $fShowName $fEqNameError$fShowNameErrorTypeExtensionDefinitionInputObjectTypeDefinitionEnumValueDefinitionEnumTypeDefinitionScalarTypeDefinitionUnionTypeDefinitionInterfaceTypeDefinitionInputValueDefinitionArgumentsDefinitionFieldDefinition InterfacesObjectTypeDefinitionTypeDefinitionTypeDefinitionObjectTypeDefinitionInterfaceTypeDefinitionUnionTypeDefinitionScalarTypeDefinitionEnumTypeDefinitionInputObjectTypeDefinitionTypeExtension NonNullTypeNonNullTypeNamedNonNullTypeListListType NamedTypeGType TypeNamedTypeList TypeNonNull Directive DefaultValue ObjectField ObjectValue ListValue StringValue ValueVariableValueInt ValueFloat ValueBoolean ValueString ValueEnum ValueList ValueObject ValueNull TypeConditionFragmentDefinitionInlineFragmentFragmentSpreadArgumentAliasField SelectionSelectionFieldSelectionFragmentSpreadSelectionInlineFragment SelectionSetVariableNodeOperationDefinitionQueryMutationAnonymousQuerySchemaDocument DefinitionDefinitionOperationDefinitionFragment QueryDocumentgetDefinitions$fArbitraryVariable$fArbitraryStringValue$fArbitraryObjectField$fArbitraryObjectValue$fArbitraryListValue$fArbitraryValue$fHasNameGType $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 $fEqGType $fOrdGType $fShowGType$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$fShowSchemaDocument queryDocumentschemaDocumentvalue ObjectField'ObjectObject'ListList'String ConstScalarUnresolvedVariableValueValue' ValueScalar' ValueList' ValueObject'toObject objectFields makeObjectobjectFromOrderedMapobjectFromList unionObjectsastToVariableValue valueToASTvariableValueToAST$fToJSONString$fArbitraryString$fArbitraryConstScalar$fToJSONConstScalar$fToJSONObject'$fArbitraryObject'$fTraversableObject'$fFoldableObject' $fToJSONList'$fArbitraryList'$fTraversableList'$fFoldableList'$fArbitraryValue'$fToJSONValue'$fTraversableValue'$fFoldableValue'$fArbitraryObjectField' $fEqString $fOrdString $fShowString$fEqConstScalar$fOrdConstScalar$fShowConstScalar $fEqObject' $fOrdObject' $fShowObject'$fFunctorObject' $fEqValue' $fOrdValue' $fShowValue'$fFunctorValue' $fEqList' $fOrdList' $fShowList'$fFunctorList'$fEqObjectField'$fOrdObjectField'$fShowObjectField'$fFunctorObjectField'ToValuetoValue$fToValueObject'$fToValueList' $fToValueText$fToValueString$fToValueDouble$fToValueInt32 $fToValueBool$fToValueNonEmpty$fToValueMaybe $fToValue[]$fToValueValue' FromValue fromValueprop_roundtripValue wrongType$fGenericFromValueM1$fGenericFromValue:*:$fGenericFromValueM10$fGenericFromValueM11$fFromValueMaybe$fFromValueNonEmpty $fFromValue[]$fFromValueText$fFromValueBool$fFromValueDouble$fFromValueInt32InputTypeDefinitionInputTypeDefinitionObjectInputTypeDefinitionScalarInputTypeDefinitionEnum InputTypeDefinedInputTypeBuiltinInputTypeInputObjectFieldDefinitionBuiltinGIntGBoolGStringGFloatGIDArgumentDefinition DefinedType BuiltinType AnnotatedType DefinesTypesgetDefinedTypesSchema makeSchema emptySchema lookupTypedoesFragmentTypeApplygetInputTypeDefinitionbuiltinFromNameastAnnotationToSchemaAnnotation$fHasNameAnnotatedType$fHasNameScalarTypeDefinition$fHasNameBuiltin$fHasNameEnumValueDefinition$fHasNameEnumTypeDefinition$fHasNameInputTypeDefinition$fHasNameInputType#$fHasNameInputObjectFieldDefinition"$fHasNameInputObjectTypeDefinition$fHasNameArgumentDefinition $fHasNameTypeExtensionDefinition$fHasNameUnionTypeDefinition $fHasNameInterfaceTypeDefinition$fHasNameFieldDefinition$fHasNameObjectTypeDefinition$fHasNameTypeDefinition!$fDefinesTypesInputTypeDefinition$fDefinesTypesInputType $fDefinesTypesEnumTypeDefinition"$fDefinesTypesScalarTypeDefinition!$fDefinesTypesUnionTypeDefinition%$fDefinesTypesInterfaceTypeDefinition $fDefinesTypesArgumentDefinition$fDefinesTypesFieldDefinition"$fDefinesTypesObjectTypeDefinition$fDefinesTypesTypeDefinition$fDefinesTypesGType$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 $fShowSchema GraphQLError formatErrortoErrorErrorErrorsResponseSuccessPreExecutionFailureExecutionFailurePartialSuccess singleError$fToValueLocation$fToValueError$fToJSONResponse$fToValueResponse$fGraphQLErrorNameError $fEqLocation $fOrdLocation$fShowLocation $fEqError $fOrdError $fShowError $fEqResponse $fOrdResponse$fShowResponseValidationErrorsValidationErrorDuplicateOperationMixedAnonymousOperationsDuplicateArgumentDuplicateFragmentDefinitionNoSuchFragmentDuplicateDirectiveDuplicateVariableDefinitionCircularFragmentSpreadUnusedFragmentsUnusedVariablesUndefinedVariable InvalidValueInvalidDefaultValueMismatchedNamesMismatchedArgumentsIncompatibleFieldsTypeConditionNotFoundVariableTypeNotFoundVariableTypeIsNotInputType VariableValuevariable variableType defaultValue ResponseKeySelectionSetByType OperationLoneAnonymousOperationMultipleOperationsgetSelectionSetvalidatelookupArgumentgetSubSelectionSetgetSelectionSetForTypegetResponseKey getErrorsfindDuplicates formatErrors$fHasNameField%$fTraversableUnresolvedFragmentSpread"$fFoldableUnresolvedFragmentSpread$fTraversableInlineFragment$fFoldableInlineFragment$fFunctorInlineFragment$fTraversableField'$fFoldableField'$fFunctorField'$fHasNameField'$fTraversableFragmentDefinition$fFoldableFragmentDefinition$fFunctorFragmentDefinition$fTraversableFragmentSpread$fFoldableFragmentSpread$fFunctorFragmentSpread$fTraversableOperation$fFoldableOperation$fFunctorOperation$fGraphQLErrorValidationError$fApplicativeValidator$fEqOperationType$fShowOperationType $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$fMonadValidator GraphQLEnum enumValues enumFromValue enumToValue$fGenericEnumValues:+:$fGenericEnumValuesM1$fGenericEnumValuesM10$fGenericEnumValues:+:0$fGenericEnumValuesM11HasAnnotatedInputTypegetAnnotatedInputTypeHasAnnotatedTypegetAnnotatedTypegetArgumentDefinitiongetInterfaceDefinitiongetFieldDefinitionHasObjectDefinition getDefinition Defaultable defaultFor SchemaErrorEmptyFieldList EmptyUnion InterfaceUnionEnum:>$fGraphQLErrorSchemaError$fDefaultableMaybe$fDefaultableText$fDefaultableBool$fDefaultableDouble$fDefaultableInt32 $fHasFieldDefinitionTYPEArgument$fHasFieldDefinitions[][]$fHasFieldDefinitions[]:'$fHasUnionTypeObjectTypeDefinitions[][]&$fHasUnionTypeObjectTypeDefinitions[]:$fHasObjectDefinitionTYPEObject$fHasInterfaceDefinitions[][]%$fHasInterfaceDefinitionTYPEInterface$fHasInterfaceDefinitions[]:$fHasFieldDefinitionTYPE:>$fHasAnnotatedTypeTYPEInteger$fHasAnnotatedTypeTYPEUnion$fHasAnnotatedTypeTYPEEnum$fHasAnnotatedTypeTYPEList$fHasAnnotatedTypeTYPEFloat$fHasAnnotatedTypeTYPEDouble$fHasAnnotatedTypeTYPEText$fHasAnnotatedTypeTYPEBool$fHasAnnotatedTypeTYPEInt32$fHasAnnotatedTypeTYPEInt$fHasAnnotatedTypeTYPEMaybe$fHasFieldDefinitionTYPEField$fHasAnnotatedTypeTYPEObject$fHasAnnotatedInputTypeEnum$fHasAnnotatedInputTypeList$fHasAnnotatedInputTypeFloat$fHasAnnotatedInputTypeDouble$fHasAnnotatedInputTypeText$fHasAnnotatedInputTypeBool$fHasAnnotatedInputTypeInt32$fHasAnnotatedInputTypeInt$fHasAnnotatedInputTypeMaybe#$fHasArgumentDefinitionTYPEArgument&$fGenericInputObjectFieldDefinitionsM1'$fGenericInputObjectFieldDefinitions:*:$fGenericAnnotatedInputTypeM1$fEqSchemaError$fShowSchemaErrorOperationResolverConstraint HasResolverHandlerresolveResult:<> ResolverErrorFieldNotFoundError ValueMissingSubSelectionOnLeafMissingSelectionSet HandlerErrorreturns handlerErrorresolveOperation unionValue$fGraphQLErrorResolverError$fApplicativeResult$fHasResolverTYPEmMaybe$fHasResolverTYPEmEnum$fHasResolverTYPEmList$fHasResolverTYPEmBool$fHasResolverTYPEmText$fHasResolverTYPEmDouble$fHasResolverTYPEmInt32!$fBuildFieldResolvermEnumArgument"$fBuildFieldResolvermPlainArgument $fBuildFieldResolvermJustHandler$fHasResolverTYPEmObject$fRunFieldsm:>$fRunFieldsmField$fRunFieldsm:<>$fHasResolverTYPEmUnion$fRunUnion[]munion[]$fRunUnion[]munion:$fShowResolverError$fEqResolverError $fShowResult$fFunctorResult $fEqResultVariableValuesExecutionError MissingValueNoSuchOperationNoAnonymousOperation getOperationsubstituteVariables$fGraphQLErrorExecutionError$fEqExecutionError$fShowExecutionError QueryError executeQueryinterpretQueryinterpretAnonymousQuery compileQuery$fGraphQLErrorQueryError$fEqQueryError$fShowQueryError text-1.2.3.1Data.Text.InternalTextbaseGHC.BaseNonEmpty GHC.MaybeNothingMaybeghc-prim GHC.TypesSymbolUnresolvedVariableScalargenValueconstScalarToAST variableToAST astToScalar genObject astToValue' valueToAST'getValueunsafeMakeObject Validator Validation Directives ArgumentsUnresolvedFragmentSpreadField' Selection'OperationBuildervalidateSelectionSettransformers-0.5.5.0Control.Monad.Trans.State.LazyStateT mergeFieldsgroupByResponseKeytraverseFragmentSpreadsData.Traversable TraversablevalidateSelectionresolveSelectionvalidateFragmentDefinitionsvalidateTypeConditionresolveFragmentDefinitionsvalidateArgumentsvalidateVariableDefinitionsvalidateVariableDefinitionvalidateTypeAssertionvalidateVariableTypeDefinitionvalidateVariableTypeBuiltinvalidateDefaultValue getVariablesvalidateValuesresolveVariablesvalidateDirectivesmakeMap Data.EitherLeftthrowE throwErrors mapErrorsData.Bifunctorfirst Bifunctor dropNonNullDynamicUnionValue TypeIndex runFields FieldHandler HandlerResult valueMissing ParseErrorNonObjectResult parseQueryversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName