anchor.diff:  /// Builds the result tree for a given query
   let rec private buildResolverTree (returnDef: OutputDef) (ctx: ResolveFieldContext) (fieldExecuteMap: FieldExecuteMap) (value: obj option) : AsyncVal<ResolverTree> =
       let name = ctx.ExecutionInfo.Identifier
  -    match ctx.ExecutionInfo.Kind with
  -    | ResolveNull ->
  -        asyncVal { return ResolverLeaf { Name = ctx.ExecutionInfo.Identifier; Value = None } }
  -    | ResolveEmpty ->
  -        asyncVal { return ResolverListNode { Name = ctx.ExecutionInfo.Identifier; Value = Some (upcast [ ]); Children = [| |] } }
  +    match ctx.ExecutionInfo.Kind, returnDef with
  +    | ResolveNull, (Scalar _ | Enum _ | Nullable _) ->
  +        asyncVal { return ResolverLeaf { Name = name; Value = None; DeferredValue = value } }
  +    | ResolveNull, (Object _ | Interface _ | Union _) ->
  +        asyncVal { return ResolverObjectNode { Name = name; Value = None; DeferredValue = value; Children = [| |] } }
  +    | ResolveEmpty, List _ ->
  +        asyncVal { return ResolverListNode { Name = name; Value = Some (upcast [ ]); DeferredValue = value; Children = [| |] } }
       | _ ->
           match returnDef with
           | Object objdef ->
  
positive.code:                 | ResolverError e when not info.IsNullable -> propagateError name e
                  | _ when not info.IsNullable && tree.Value.IsNone -> asyncVal { return ResolverError { Name = name; Message = ctx.Schema.ParseError(GraphQLException (sprintf "Non-Null field %s resolved as a null!" info.Identifier)); PathToOrigin = [info.Identifier]}}
                  | t -> build (t::acc) xs)
          | [] -> asyncVal { return ResolverObjectNode{ Name = name; Value = Some value; Children = acc |> List.rev |> List.toArray } }
      build [] fields
  
  let internal compileSubscriptionField (subfield: SubscriptionFieldDef) = 
  
negative.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 =
  