anchor.diff:                          else
                               let t = buildResolverTree innerdef innerCtx fieldExecuteMap (toOption value)
                               build (t::acc) xs
  -                    | [] -> asyncVal { return ResolverListNode { Name = name; Value = value; Children = acc |> List.rev |> List.toArray } }
  +                    | [] -> asyncVal { return ResolverListNode { Name = name; Value = value; Children = acc |> List.map (AsyncVal.map (fun x -> x)) |> List.rev |> List.toArray } }
               match value with
               | None when not ctx.ExecutionInfo.IsNullable -> nullResolverError name
               | None -> asyncVal { return ResolverListNode { Name = name; Value = None; Children = [| |] } }
  
positive.code:           Args = args
            Variables = ctx.Variables }
      subscriptionProvider.Add fieldCtx value subdef
      |> Observable.bind(fun v ->
          buildResolverTree returnType fieldCtx fieldExecuteMap (Some v)
          |> AsyncVal.map(treeToDict)
          |> AsyncVal.map(fun (data, err) -> 
              let output = NameValueLookup.ofList[nameOrAlias, data.Value]                
              match err with
  
negative.code:                 listOp path' node.Name node.Value ts
          helper []
  
  let private foldChildren (children : AsyncVal<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 = child
          let! c, e = c
          return c::kvps, e@errs
      }) (Value ([], []))
  
  let private treeToDict =
      ResolverTree.pathFold
          (fun _ leaf -> asyncVal { return KeyValuePair<_,_>(leaf.Name, match leaf.Value with | Some v -> v | None -> null), [] })
          (fun path error -> asyncVal {
              let (e:Error) = (error.Message, path |> List.rev)
              return KeyValuePair<_,_>(error.Name, box null), [e]})
          (fun _ name value children -> asyncVal {
              let! dicts, errors = children |> foldChildren
              match value with
              | Some _ -> return KeyValuePair<_,_>(name, NameValueLookup(dicts |> List.rev |> List.toArray) |> box), errors
              | None -> return KeyValuePair<_,_>(name, null), errors})
          (fun _ name value children -> asyncVal {
              let! dicts, errors = children |> foldChildren
              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})
  
  let private errorDict tree message path = asyncVal {
      let! data, err = treeToDict tree
      return (data, (message, path) :: err)
  }
  
  let private nullResolverError name = asyncVal { return ResolverError{ Name = name; Message = sprintf "Non-Null field %s resolved as a null!" name; PathToOrigin = []} }
  
  