anchor.diff:  module internal ProvidedRecord =
       let ctor = typeof<RecordBase>.GetConstructors().[0]
   
  -    // TODO: this function was created in order to generate overloads for the record type constructors.
  -    // It could receive a review in the future to see if improvements can be done to generate all
  -    // combinations of constructor overloads.
  -    let combine (input : 'T list) =
  -        let rec helper (input : 'T list) (startIndex : int) (length : int) =
  -            let mutable combinations = List<List<'T>>()
  -            if length = 2
  -            then
  -                let mutable combinationsIndex = 0
  -                for inputIndex = startIndex to (input.Length - 1) do
  -                    for i = (inputIndex + 1) to (input.Length - 1) do
  -                        combinations.Add(List<'T>())
  -                        combinations.[combinationsIndex].Add(input.[inputIndex])
  -                        while combinations.[combinationsIndex].Count < length do
  -                            combinations.[combinationsIndex].Add(input.[i])
  -                        combinationsIndex <- combinationsIndex + 1
  -                combinations
  -            else
  -                let combinationsOfMore = List<List<'T>>()
  -                for i = startIndex to (input.Length - length) do
  -                    combinations <- helper input (i + 1) (length - 1)
  -                    for index = 0 to (combinations.Count - 1) do
  -                        combinations.[index].Insert(0, input.[i])
  -                    for y = 0 to (combinations.Count - 1) do
  -                        combinationsOfMore.Add(combinations.[y])
  -                combinationsOfMore
  -        let output = List<List<'T>>()
  -        output.Add(List<'T>())
  -        for i = 0 to (input.Length - 1) do
  -            let item = List<'T>()
  -            item.Add(input.[i])
  -            output.Add(item)
  -        for i = 2 to input.Length do
  -            helper input 0 i |> output.AddRange
  -        output
  -        |> Seq.map List.ofSeq
  -        |> List.ofSeq
  -        |> List.map (fun x -> x, List.except x input)
  -
       let makeProvidedType(tdef : ProvidedRecordTypeDefinition, properties : RecordPropertyMetadata list) =
           let name = tdef.Name
           let propertyMapper (metadata : RecordPropertyMetadata) : MemberInfo =
  
positive.code:                         (name, mapper %%value) @@>
                  let args =
                      let names = variables |> List.map fst
                      let args = 
                          match contextInfo with
                          | Some _ ->
                              match args with
                              | _ :: tail when tail.Length > 0 -> List.take (tail.Length - 1) tail
                              | _ -> []
                          | None ->
                              match args with
                              | _ :: _ :: tail when tail.Length > 0 -> tail
                              | _ -> []
                      List.zip names args |> List.map exprMapper
                  Expr.NewArray(typeof<string * obj>, args)
              let defaultContextExpr = 
  
negative.code: namespace FSharp.Data.GraphQL
  
  open System
  open System.Security.Cryptography
  open FSharp.Core
  open System.Reflection
  