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:     | _ -> resolve ctx.ExecutionInfo.Kind
  
  and buildObjectFields (fields: ExecutionInfo list) (objdef: ObjectDef) (ctx: ResolveFieldContext) (fieldExecuteMap: FieldExecuteMap) (name: string) (value: obj): AsyncVal<ResolverTree> =
      let rec build (acc: ResolverTree list) = function
          | info::xs ->
              let argDefs = fieldExecuteMap.GetArgs(objdef.Name, info.Definition.Name)
              let fieldCtx = createFieldContext objdef argDefs ctx info
              let execute = fieldExecuteMap.GetExecute(objdef.Name, info.Definition.Name)
              resolveField execute fieldCtx value
              |> AsyncVal.bind (buildResolverTree info.ReturnDef fieldCtx fieldExecuteMap)
              |> AsyncVal.rescue (fun e -> ResolverError { Name = info.Identifier; Message = ctx.Schema.ParseError e; PathToOrigin = []})
              |> AsyncVal.bind (fun tree ->
                  match tree with
                  | ResolverError e when not info.IsNullable -> propagateError name e
                  | _ when not info.IsNullable && tree.Value.IsNone -> asyncVal { return ResolverError { Name = name; Message = ctx.Schema.ParseError(GraphQLException (sprintf "Non-Null field %s resolved as a null!" info.Identifier)); PathToOrigin = [info.Identifier]}}
                  | t -> build (t::acc) xs)
          | [] -> asyncVal { return ResolverObjectNode { Name = name; Value = Some value; Children = acc |> List.rev |> List.toArray } }
      build [] fields
  
  
negative.code:                 nodeOp path' node.Name node.Value ts
              | ResolverListNode node ->
                  let path' = (node.Name :> obj)::path
                  let mapper (i : int) (c : AsyncVal<ResolverTree>) = asyncVal {
                      let! c' = c
                      return helper ((box i)::path') c'
                  }
  