anchor.diff:                  listOp path' node.Name node.Value ts
           helper []
   
  -let private foldChildren (children : AsyncVal<KeyValuePair<string, obj> * Error list> []) =
  -    children
  -    |> Array.fold (fun (kvpsErrs : AsyncVal<KeyValuePair<string, obj> list * Error list>) child -> asyncVal {
  -        let! kvps, errs = kvpsErrs
  -        let! c, e = child
  -        return c::kvps, e@errs
  -    }) (Value ([], []))
  -
   let private treeToDict =
       ResolverTree.pathFold
           (fun _ leaf -> KeyValuePair<_,_>(leaf.Name, match leaf.Value with | Some v -> v | None -> null), [])
           (fun path error ->
               let (e:Error) = (error.Message, path |> List.rev)
  -            KeyValuePair<_,_>(error.Name, box null), [e])
  -        (fun _ name value children -> asyncVal {
  -            let dicts = children |> List.ofArray |> List.map (AsyncVal.ofAsync >> AsyncVal.map fst)
  -            let errors = children |> List.ofArray |> List.map (AsyncVal.ofAsync >> AsyncVal.map snd)
  -            let! dicts, errors = children |> foldChildren
  +            KeyValuePair<_,_>(error.Name, null :> obj), [e])
  +        (fun _ name value children ->
  +            let dicts, errors = children |> Array.map AsyncVal.get |> Array.fold(fun (kvps, errs) (c, e) -> c::kvps, e@errs) ([], [])
               match value with
  -            | Some _ -> return KeyValuePair<_,_>(name, box NameValueLookup(dicts |> List.rev |> List.toArray)), errors
  -            | None -> return KeyValuePair<_,_>(name, null), errors})
  -        (fun _ name value children -> asyncVal {
  -            let! dicts, errors = children |> foldChildren
  +            | Some _ -> KeyValuePair<_,_>(name, NameValueLookup(dicts |> List.rev |> List.toArray) :> obj), errors
  +            | None -> KeyValuePair<_,_>(name, null), errors)
  +        (fun _ name value children ->
  +            let dicts, errors = children |> Array.map AsyncVal.get |> Array.fold(fun (kvps, errs) (c, e) -> c::kvps, e@errs) ([], [])
               match value with
  -            | Some _ -> return KeyValuePair<_,_>(name, dicts |> List.map(fun d -> d.Value) |> List.rev |> List.toArray |> box), errors
  -            | None -> return KeyValuePair<_,_>(name, null), errors})
  +            | Some _ -> KeyValuePair<_,_>(name, dicts |> List.map(fun d -> d.Value) |> List.rev |> List.toArray :> obj), errors
  +            | None -> KeyValuePair<_,_>(name, null), errors)
   
   let private errorDict tree message path =
       let data, err = treeToDict tree
  
positive.code:     let mapLiveResult (tree : ResolverTree) (path : obj list) (d : DeferredExecutionInfo) (fieldCtx : ResolveFieldContext) =
          let getFieldName (node : ResolverNode) =
              match node.Children |> Array.tryHead with
              | Some c -> c.Name
              | None -> failwithf "Expected a child for the object %A, but got none." node.Value
          let rec getObjectName (returnDef : OutputDef) (value : obj) (possibleTypesFn : TypeDef -> ObjectDef []) =
              match returnDef with
  
negative.code:                 nodeOp path' node.Name node.Value ts
              | ResolverListNode node ->
                  let path' = (node.Name :> obj)::path
                  let mapper (i : int) (c : AsyncVal<ResolverTree>) = asyncVal {
                      let! c' = c
                      return helper ((box i)::path') c'
                  }
  