anchor.diff:          if str <> null && str.Length > 0
           then str.[0].ToString().ToUpper() + str.Substring(1)
           else str
  +
  +    let deserializeSchema (json : string) =
  +        let result = Serialization.fromJson json
  +        match result.Errors with
  +        | None ->
  +            let introspectionSchema = result.Data.__schema
  +            Choice1Of2 introspectionSchema
  +        | Some errors ->
  +            Choice2Of2 errors
   
       let requestSchema (url: string) =
           async {
  
positive.code:             use stream = resp.GetResponseStream()
              use reader = new StreamReader(stream)
              let! json = reader.ReadToEndAsync() |> Async.AwaitTask
              let result = Serialization.fromJson json
              match result.Errors with
              | None ->
                  let introspectionSchema = result.Data.__schema
                  return Choice1Of2 introspectionSchema
              | Some errors ->
                  return Choice2Of2 errors
          }
  
      let compileTypesFromSchema asm ns (schema: IntrospectionSchema) = 
  
negative.code:     do
          let ns = "FSharp.Data.GraphQL"
          let generator = ProvidedTypeDefinition(asm, ns, "GraphQLProvider", Some typeof<obj>)
          let handleSchema typeName serverUrl choice =
              match choice with
              | Choice1Of2 schema ->
                  let tdef = ProvidedTypeDefinition(asm, ns, typeName, Some typeof<obj>)
                  let schemaTypes =
                      Util.compileTypesFromSchema asm "GraphQLTypes" schema
                  // Inner types
                  let typesWrapper = ProvidedTypeDefinition("Types", Some typeof<obj>)
                  schemaTypes
                  |> Seq.choose (fun kv ->
                      match kv.Value with
                      | ProvidedType(t,_) -> Some t
                      | NativeType _ -> None)
                  |> Seq.toList
                  |> typesWrapper.AddMembers
                  tdef.AddMember typesWrapper
                  // Static methods
                  Util.createMethods tdef serverUrl schema schemaTypes (Some schema.QueryType)
                  Util.createMethods tdef serverUrl schema schemaTypes schema.MutationType
                  Util.createMethods tdef serverUrl schema schemaTypes schema.SubscriptionType
                  // Generic query method
                  let invokeCode = fun (argValues:Expr list) ->
                      <@@ launchRequest serverUrl null null id (%%argValues.[0]: string) @@>
                  let m = ProvidedMethod("Query", [ProvidedParameter("query", typeof<string>)], typeof<Async<obj>>, invokeCode, true)
                  tdef.AddMember m
                  tdef
              | Choice2Of2 ex -> String.concat "\n" ex |> failwithf "%s"
          generator.DefineStaticParameters([ProvidedStaticParameter("url", typeof<string>)], fun typeName parameterValues ->
              match parameterValues with 
              | [| :? string as serverUrl |] ->
                  Util.requestSchema(serverUrl) 
                  |> Async.RunSynchronously
                  |> handleSchema typeName serverUrl
              | [| :? string as serverUrl; :? string as introspection |] ->
                  Util.deserializeSchema introspection
                  |> handleSchema typeName serverUrl
              | _ -> failwith "unexpected parameter values")
          this.AddNamespace(ns, [generator])
  
  