anchor.diff:                      traversePath d fieldCtx d.Path (AsyncVal.wrap tree) [(List.head d.Path)]
                       |> AsyncVal.bind(Array.map(fun (tree, path) ->
                           asyncVal {
  -                            return
  -                                // TODO: what to do with streamed errors?
  -                                treeToDictSeq tree
  -                                |> Seq.map (fun (d, _) -> NameValueLookup.ofList["data", d.Value; "path", upcast path])
  +                            let d, _ = treeToDict tree
  +                            match d.Value with
  +                            | :? NameValueLookup as x -> 
  +                                return 
  +                                    x |> Seq.map (fun x -> 
  +                                        match x.Value with
  +                                        | :? IEnumerable<obj> as y -> 
  +                                            y |> Seq.mapi (fun i x -> NameValueLookup.ofList["data", x; "path", upcast ((path |> List.map (fun x -> x :> obj)) @ [i])])
  +                                        | _ -> Seq.singleton (NameValueLookup.ofList["data", d.Value; "path", upcast path]))
  +                                    |> Seq.collect id
  +                            | _ -> return Seq.singleton (NameValueLookup.ofList["data", d.Value; "path", upcast path])
                           }) >> AsyncVal.collectParallel))
                   |> AsyncVal.collectParallel
  -                |> AsyncVal.map(Array.fold (Array.append) [||])))
  +                |> AsyncVal.map (Array.fold Array.append Array.empty)))
               |> AsyncVal.collectParallel
  -            |> AsyncVal.map(Array.fold (Array.append) [||])
  +            |> AsyncVal.map (Array.fold Array.append Array.empty)
               |> AsyncVal.toAsync
               |> Observable.ofAsync
  -            |> Observable.bind(fun i -> i |> Observable.ofSeq)
  -            |> Observable.bind(fun i -> i |> Observable.ofSeq)
  +            |> Observable.bind Observable.ofSeq
  +            |> Observable.bind Observable.ofSeq
               |> Some
       dict, deferredResults, streamedResults
   
  
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
  