anchor.diff:                  let schemaArgumentNames =
                       metaTypeFields.TryFind(selection.Field.Name)
                       |> Option.map (fun x -> x.ArgumentNames)
  -                    |> Option.orElseWith (fun () -> selection.InputValues |> Option.map (Array.map (fun x -> x.Name)))
  -                match schemaArgumentNames |> tryFindInArrayOption (fun x -> x = arg.Name) with
  +                    |> Option.defaultValue (selection.InputValues |> Array.map (fun x -> x.Name))
  +                match schemaArgumentNames |> Array.tryFind (fun x -> x = arg.Name) with
                   | Some _ -> Success
                   | None -> AstError.AsResult(sprintf "Field '%s' of type '%s' does not have an input named '%s' in its definition." selection.Field.Name selection.FragmentOrParentType.Name arg.Name, selection.Path))
           let directivesValid =
  
positive.code: 
      let internal validateRequiredArguments (ctx : ValidationContext) =
          ctx.Definitions
          |> collectResults (fun def -> def.NonCyclicSelectionSet |> collectResults (checkRequiredArguments ctx.Schema))
  
      let internal validateFragmentNameUniqueness (ctx : ValidationContext) =
          let counts = Dictionary<string, int>()
  
negative.code:                         match selection.FragmentSpreadName with
                          | Some spreadName -> spreadName :: visitedFragments
                          | None -> visitedFragments
                      let innerSelectionIsValid = checkFieldsOfType visitedFragments selection.SelectionSet
                      selectionIsValid @@ innerSelectionIsValid)
          ctx.Definitions
          |> collectResults (function def -> checkFieldsOfType [] def.SelectionSet)
  
      let private typesAreApplicable (parentType : IntrospectionType, fragmentType : IntrospectionType) =
          let parentPossibleTypes = parentType.PossibleTypes |> Option.defaultValue [||] |> Array.choose (fun x -> x.Name) |> Array.append [|parentType.Name|] |> Set.ofArray
  