anchor.diff:                  | None -> asyncVal { return ResolverError { Name = name; Message = ctx.Schema.ParseError (GraphQLException (sprintf "GraphQL Interface '%s' is not implemented by the type '%s'" idef.Name resolvedDef.Name)); PathToOrigin = [] } }
               | None ->
                   if ctx.ExecutionInfo.IsNullable
  -                then asyncVal { return ResolverObjectNode { Name = name; Value = None; DeferredValue = value; Children = [| |] } }
  +                then asyncVal { return ResolverObjectNode { Name = name; Value = None; Children = [| |] } }
                   else nullResolverError name
           | Union udef ->
               let possibleTypesFn = ctx.Schema.GetPossibleTypes
  
positive.code:         | ResolverError _ -> None
          | ResolverObjectNode node -> node.Value
          | ResolverListNode l -> l.Value
      member x.DeferredValue =
          match x with
          | ResolverLeaf leaf -> leaf.DeferredValue
          | ResolverError _ -> None
          | ResolverObjectNode node -> node.DeferredValue
          | ResolverListNode l -> l.DeferredValue
  and ResolverLeaf = { Name: string; Value: obj option; DeferredValue : obj option }
  and ResolverError = { Name: string; Message: string; PathToOrigin: obj list; }
  and ResolverNode = { Name: string; Value: obj option; DeferredValue : obj option; Children: ResolverTree []; }
  
  module ResolverTree =
      let fold leafOp errorOp nodeOp listOp =
  
negative.code:                 | Some v -> buildObjectFields fields objdef ctx fieldExecuteMap name v
                  | None ->
                      if ctx.ExecutionInfo.IsNullable
                      then asyncVal { return ResolverObjectNode { Name = name; Value = None; Children = [| |] } }
                      else nullResolverError name
              | kind -> failwithf "Unexpected value of ctx.ExecutionPlan.Kind: %A" kind
          | Scalar scalardef ->
              let name = ctx.ExecutionInfo.Identifier
              let (coerce: obj -> obj option) = scalardef.CoerceValue
              asyncVal {
                  return ResolverLeaf { Name = name; Value = value |> Option.bind(coerce) }
              }
          | Enum _ ->
              let name = ctx.ExecutionInfo.Identifier
              asyncVal {
                  let value' = value |> Option.bind(fun v ->  coerceStringValue v |> Option.map(fun v' -> v' :> obj))
                  return ResolverLeaf { Name = name; Value = value' }
              }
          | List (Output innerdef) ->
              let innerCtx =
  