anchor.diff:              Define.Field("a", String, resolve = fun _ dt -> dt.a)
               Define.Field("b", String, resolve = fun _ dt -> dt.b)
               Define.Field("c", String, resolve = fun _ dt -> dt.c)
  -            Define.Field("hasFoo", Boolean, resolve = fun ctx _ -> ctx.Context.Variables.ContainsKey "foo")
  +            Define.Field("d", Boolean, "Returns its argument", [ Define.Input("input", Boolean) ], fun ctx _ -> ctx.Arg<bool> "input")
           ])
   let Query =
       Define.Object<TestSubject>(
  
positive.code:                     upcast NameValueLookup.ofList 
                          [ "a", upcast "Cookie" 
                            "b", upcast "Banana"
                            "hasFoo", upcast true ] ]
      match result with
      | Direct (data, errors) ->
          empty errors
  
negative.code:     ctx.FieldExecuteMap.SetExecute("Data", fieldDef)
      next ctx
  
  // After the schema has been compiled, update the input fields to flip every boolean input
  let postCompileMiddleware (schema : ISchema) (next : ISchema -> unit) =
      let flipBools execute value vars =
          match value with
          | BooleanValue b -> execute (BooleanValue (not b)) vars
          | _ -> execute value vars
      schema.TypeMap.ToSeq()
      |> Seq.iter(fun (n, def) ->
                      match def with
                      | InputObject iobj ->
                          iobj.Fields
                          |> Array.iter(fun f -> f.ExecuteInput <- (flipBools f.ExecuteInput))
                      | _ -> ())
      next schema
  
  