anchor.diff:                  nodeOp path' node.Name node.Value ts
               | ResolverListNode node ->
                   let path' = node.Name::path
  -                let ts = node.Children |> Array.mapi(fun i c -> helper (i.ToString()::path') c) 
  +                let ts = node.Children |> Array.mapi(fun i c -> helper (i.ToString()::path') c)
                   listOp path' node.Name node.Value ts
           helper []
  -
  -    let rec pathFoldSeq leafOp errorOp nodeOp listOp =
  -        let rec helperSeq path = function
  -            | ResolverLeaf leaf ->
  -                leafOp (leaf.Name::path) leaf |> Seq.singleton
  -            | ResolverError err ->
  -                let origin = (err.PathToOrigin |> List.rev)
  -                let path' = if err.Name <> "__index" then origin@(err.Name::path) else origin@path
  -                errorOp path' err |> Seq.singleton
  -            | ResolverObjectNode node ->
  -                let path' = if node.Name <> "__index" then node.Name::path else path
  -                node.Children
  -                |> Seq.collect (helperSeq path')
  -                |> nodeOp path' node.Name node.Value
  -            | ResolverListNode node ->
  -                let path' = node.Name::path
  -                node.Children
  -                |> Seq.mapi (fun i c -> helperSeq (i.ToString()::path') c)
  -                |> Seq.collect id
  -                |> listOp path' node.Name node.Value
  -        helperSeq [] 
   
   let private treeToDict =
       ResolverTree.pathFold 
  
positive.code:             match value with
              | Some v -> KeyValuePair<_,_>(name, dicts |> List.map(fun d -> d.Value) |> List.rev |> List.toArray :> obj), errors
              | None -> KeyValuePair<_,_>(name, null), errors)
  
  let private treeToDictSeq =
      ResolverTree.pathFoldSeq 
          (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, null :> obj), [e])
          (fun _ name value children -> 
              match value with
              | Some _ -> children |> Seq.map (fun (c, e) -> KeyValuePair<_, _>(name, NameValueLookup([|c|]) :> obj), e)
              | None -> 
                  let _, errors = children |> Seq.fold(fun (kvps, errs) (c, e) -> c::kvps, e@errs) ([], [])
                  (KeyValuePair<_,_>(name, null), errors) |> Seq.singleton)
          (fun _ name value children -> 
              match value with
              | Some _ -> children |> Seq.map (fun (c, e) -> KeyValuePair<_, _>(name, [|c.Value|] :> obj), e)
              | None -> 
                  let _, errors = children |> Seq.fold(fun (kvps, errs) (c, e) -> c::kvps, e@errs) ([], [])
                  (KeyValuePair<_,_>(name, null), errors) |> Seq.singleton)
  
  let private nullResolverError name = asyncVal { return ResolverError{ Name = name; Message = sprintf "Non-Null field %s resolved as a null!" name; PathToOrigin = []} }
  let private propagateError name err = asyncVal { return ResolverError{ Name = name; Message = err.Message; PathToOrigin = err.Name::err.PathToOrigin} }
  
negative.code:                             return NameValueLookup.ofList["data", d.Value; "path", upcast path]
                          }) >> AsyncVal.collectParallel))
                  |> AsyncVal.collectParallel
                  |> AsyncVal.map (Array.fold Array.append Array.empty)))
              |> AsyncVal.collectParallel
              |> AsyncVal.map (Array.fold Array.append Array.empty)
              |> AsyncVal.toAsync
              |> Observable.ofAsync
              |> Observable.bind Observable.ofSeq
              |> Some
      let streamedResults =
          if ctx.ExecutionPlan.StreamedFields.Length = 0
  