anchor.diff:            Args = args
             Variables = ctx.Variables }
       subscriptionProvider.Add fieldCtx value subdef
  -    |> Observable.bind(fun v ->
  -        buildResolverTree returnType fieldCtx fieldExecuteMap (Some v)
  -        |> AsyncVal.map(treeToDict)
  +    |> Observable.bind(fun v -> 
  +        let dict = asyncVal {
  +            let! tree = buildResolverTree returnType fieldCtx fieldExecuteMap (Some v)
  +            return! treeToDict tree
  +        }
  +        dict
           |> AsyncVal.map(fun (data, err) -> 
               let output = NameValueLookup.ofList[nameOrAlias, data.Value]                
               match err with
  
positive.code:                         asyncVal {
                              let data, err =
                                  if d.DeferredFields.Length > 0
                                  then errorDict tree "Maximum degree of nested deferred executions reached." path
                                  else treeToDict tree
                              let deferred = 
                                  match d.Kind with
                                  | LiveExecution -> Seq.empty
  
negative.code:                         else
                              let t = buildResolverTree innerdef innerCtx fieldExecuteMap (toOption value)
                              build (t::acc) xs
                      | [] -> asyncVal { return ResolverListNode { Name = name; Value = value; Children = acc |> List.map (AsyncVal.map (fun x -> x)) |> List.rev |> List.toArray } }
              match value with
              | None when not ctx.ExecutionInfo.IsNullable -> nullResolverError name
              | None -> asyncVal { return ResolverListNode { Name = name; Value = None; Children = [| |] } }
  