anchor.diff:                                Query = query
                                 Variables = %%variables }
                           async {
  +                            let sw = System.Diagnostics.Stopwatch()
  +                            sw.Start()
                               let! response = GraphQLClient.sendRequestAsync client request
  +                            sw.Stop()
  +                            printfn "Ran operation in %ims." sw.ElapsedMilliseconds
  +                            sw.Restart()
                               let responseJson = JsonValue.Parse response
  -                            return OperationResultBase(responseJson, schemaTypes, operationTypeName)
  -                        } @@>)
  +                            sw.Stop()
  +                            printfn "Converted query string response to JsonValue in %ims." sw.ElapsedMilliseconds
  +                            return OperationResultBase(responseJson, %%schemaTypes, operationTypeName)
  +                        } @@>
                   let varprm = variables |> List.map (fun (name, t) -> ProvidedParameter(name, t))
                   let prm = varprm @ [ProvidedParameter("customHttpHeaders", typeof<string>, optionalValue = "")]
                   let mdef = ProvidedMethod("AsyncRun", prm, Types.makeAsync rtdef, invoker)
  
positive.code:         let var = Var("instance", varType)  
          Expr.Let(var, instance, body args (Expr.Var(var)))
  
      let quoteUnion instance = unionExpr instance ||> createLetExpr
      let quoteRecord instance = recordExpr instance ||> createLetExpr
      let quoteArray instance = arrayExpr instance ||> createLetExpr
  
  module HttpHeaders =
      let map (location : TextLocation) =
  
negative.code:             "Operation" + hash
          let tdef = ProvidedTypeDefinition(className, Some typeof<OperationBase>)
          tdef.AddXmlDoc("Represents a GraphQL operation on the server.")
          // Every time we run the query, we will need the schema type map as an expression.
          // To avoid creating the type map expression every time we call Run method, we cache it here.
          let schemaTypes =
              let schemaTypeNames = schemaTypes |> Seq.map (fun x -> x.Key) |> Array.ofSeq
              let schemaTypes = schemaTypes |> Seq.map (fun x -> x.Value) |> Array.ofSeq |> QuotationHelpers.arrayExpr |> snd
              <@@ Array.zip schemaTypeNames (%%schemaTypes : IntrospectionType []) |> Map.ofArray @@>
          tdef.AddMembersDelayed(fun _ ->
              let rtdef = OperationResultBase.MakeProvidedType(operationType)
              let variables =
  