anchor.diff:              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} }
  
positive.code:                             return NameValueLookup.ofList["data", d.Value; "path", upcast path]
                          }) >> AsyncVal.collectParallel))
                  |> AsyncVal.collectParallel
                  |> AsyncVal.map(Array.fold (Array.append) [||])))
              |> AsyncVal.collectParallel
              |> AsyncVal.map(Array.fold (Array.append) [||])
              |> AsyncVal.toAsync
              |> Observable.ofAsync
              |> Observable.bind(Observable.ofSeq)
              |> Some
      let streamedResults =
          if ctx.ExecutionPlan.StreamedFields.Length = 0
  
negative.code:                 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)
                  listOp path' node.Name node.Value ts
          helper []
  
  let private treeToDict =
      ResolverTree.pathFold 
  