anchor.diff:          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
  +    let quoteUnion instance = 
  +        let func instance = unionExpr instance ||> createLetExpr
  +        let sw = System.Diagnostics.Stopwatch()
  +        sw.Start()
  +        let result = func instance
  +        sw.Stop()
  +        if sw.ElapsedMilliseconds > 0L then printfn "Quoted an union in %ims." sw.ElapsedMilliseconds
  +        result
  +
  +    let quoteRecord instance = 
  +        let func instance = recordExpr instance ||> createLetExpr
  +        let sw = System.Diagnostics.Stopwatch()
  +        sw.Start()
  +        let result = func instance
  +        sw.Stop()
  +        if sw.ElapsedMilliseconds > 0L then printfn "Quoted an record in %ims." sw.ElapsedMilliseconds
  +        result
  +
  +    let quoteArray instance = 
  +        let func instance = arrayExpr instance ||> createLetExpr
  +        let sw = System.Diagnostics.Stopwatch()
  +        sw.Start()
  +        let result = func instance
  +        sw.Stop()
  +        if sw.ElapsedMilliseconds > 0L then printfn "Quoted an array in %ims." sw.ElapsedMilliseconds
  +        result
   
   module HttpHeaders =
       let map (location : TextLocation) =
  
positive.code:                     List.zip names args |> List.map exprMapper
                  Expr.NewArray(typeof<string * obj>, args)
              let rundef = 
                  let invoker =
                      QuotationHelpers.quoteArray schemaTypes (fun (args : Expr list) schemaTypes ->
                          let operationName = Option.toObj operationDefinition.Name
                          let variables = varExprMapper variables args
                          <@@ let this = %%args.[0] : OperationBase
                              let schemaTypes = Array.zip schemaTypeNames %%schemaTypes |> Map.ofArray
                              let client = OperationBase.GetClientInstance(this)
                              let customHttpHeaders = 
                                  match %%args.[args.Length - 1] : string with
                                  | "" -> this.CustomHttpHeaders
                                  | other -> HttpHeaders.map (TextLocation.Create(other, resolutionFolder))
                              let request =
                                  { ServerUrl = this.ServerUrl
                                    CustomHeaders = customHttpHeaders
                                    OperationName = Option.ofObj operationName
                                    Query = query
                                    Variables = %%variables }
                              let responseJson = GraphQLClient.sendRequest client request |> JsonValue.Parse
                              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("Run", prm, rtdef, invoker)
                  mdef.AddXmlDoc("Executes the operation on the server and fetch its results.")
                  mdef
              let arundef = 
                  let invoker =
                      QuotationHelpers.quoteArray schemaTypes (fun (args : Expr list) schemaTypes ->
                      let operationName = Option.toObj operationDefinition.Name
                      let variables = varExprMapper variables args
                      <@@ let this = %%args.[0] : OperationBase
                          let schemaTypes = Array.zip schemaTypeNames %%schemaTypes |> Map.ofArray
                          let client = OperationBase.GetClientInstance(this)
                          let customHttpHeaders = 
                              match %%args.[args.Length - 1] : string with
  
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 =
  