anchor.diff:              match x with
               | OperationDefinitionInfo x -> x.Definition.Directives
               | FragmentDefinitionInfo x -> x.Definition.Directives
  +        /// Gets the selection set that does not make cyclic references to a specific Fragment.
  +        member x.NonCyclicSelectionSet = x.SelectionSet |> List.choose (function SelectionField x -> Some x | _ -> None)
       
       /// The validation  context used to run validations against a parsed document.
       /// It should have the schema type information, the original document and the definition information about the original document.
  
positive.code:                 def.Definition.VariableDefinitions
                  |> List.choose (fun varDef -> ctx.Schema.TryGetInputType(varDef.Type) |> Option.map(fun t -> varDef.VariableName, (varDef, t)))
                  |> Map.ofList
              def.SelectionSet |> collectResults (checkVariableUsageAllowedOnSelection varNamesAndTypeRefs visitedFragments))
  
      let private allValidations =
          [ validateFragmentsMustNotFormCycles
  
negative.code:         |> Array.map (fun x -> x.Name, x)
          |> Map.ofArray
  
      let rec private tryGetSchemaTypeByRef (schemaTypes : Map<string, IntrospectionType>) (tref : IntrospectionTypeRef) =
          match tref.Kind with
          | TypeKind.NON_NULL | TypeKind.LIST when tref.OfType.IsSome -> tryGetSchemaTypeByRef schemaTypes tref.OfType.Value
          | _ -> tref.Name |> Option.bind schemaTypes.TryFind
  
      type SchemaInfo =
          { SchemaTypes : Map<string, IntrospectionType>
            QueryType : IntrospectionType option
            SubscriptionType : IntrospectionType option
            MutationType : IntrospectionType option
            Directives : IntrospectionDirective [] }
          member x.TryGetTypeByRef(tref : IntrospectionTypeRef) =
              tryGetSchemaTypeByRef x.SchemaTypes tref
          static member FromIntrospectionSchema(schema : IntrospectionSchema) =
              let schemaTypes = schema.Types |> Seq.map (fun x -> x.Name, x) |> Map.ofSeq
              { SchemaTypes = schema.Types |> Seq.map (fun x -> x.Name, x) |> Map.ofSeq
                QueryType = tryGetSchemaTypeByRef schemaTypes schema.QueryType
                MutationType = schema.MutationType |> Option.bind (tryGetSchemaTypeByRef schemaTypes)
                SubscriptionType = schema.SubscriptionType |> Option.bind (tryGetSchemaTypeByRef schemaTypes)
                Directives = schema.Directives }
          member x.TryGetOperationType(ot : OperationType) =
              match ot with
  