anchor.diff:                      asyncVal {
                           let! res =
                               l.Children
  +                            |> Array.map AsyncVal.get
                               |> Array.mapi(fun i c ->
                                   traversePath d fieldCtx p (AsyncVal.wrap c) (i :> obj :: pathAcc))
                               |> AsyncVal.collectParallel
  
positive.code:                 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
              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
              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 =
      let data, err = treeToDict tree
  
negative.code:         | ResolverListNode l -> l.Value
  and ResolverLeaf = { Name: string; Value: obj option }
  and ResolverError = { Name: string; Message: string; PathToOrigin: obj list }
  and ResolverNode = { Name: string; Value: obj option; Children: AsyncVal<ResolverTree> [] }
  
  module ResolverTree =
      let rec pathFold leafOp errorOp nodeOp listOp =
  