anchor.diff:                  return r.Value
               } |> Async.RunSync
   
  +    interface ICloudTaskCompletionSource<'T> with
  +        member x.Dispose(): Async<unit> = async.Zero()
  +
  +        member x.SetCompleted(t : 'T): Async<unit> = 
  +            x.SetResult(Completed t) |> Async.Ignore
  +        
  +        member x.SetException(edi: ExceptionDispatchInfo): Async<unit> = 
  +            x.SetResult(Exception edi) |> Async.Ignore
  +        
  +        member x.SetCancelled(exn: OperationCanceledException): Async<unit> =
  +            x.SetResult(Cancelled exn) |> Async.Ignore
  +        
  +        member x.Task: ICloudTask<'T> = x :> _
  +        
  +
       /// Initialize a new result cell in the local process
  -    static member Init() : ResultCell<'T> =
  +    static member Init() : TaskCompletionSource<'T> =
           let behavior state msg = async {
               match msg with
               | SetResult (_, rc) when Option.isSome state -> 
  
positive.code:             |> Actor.Publish
              |> Actor.ref
  
          new Latch(ref)
  
  //
  //  Distributed read-only cell
  
negative.code:         return resource :?> 'T
      }
  
      member __.RequestCounter(count) = __.RequestResource(fun () -> Counter.Init(count))
      member __.RequestResultAggregator<'T>(count : int) = __.RequestResource(fun () -> ResultAggregator<'T>.Init(count))
      member __.RequestCancellationEntry() = __.RequestResource(fun () -> CancellationEntry.Init())
      member __.RequestResultCell<'T>() = __.RequestResource(fun () -> TaskCompletionSource<'T>.Init())
      member __.RequestChannel<'T>(id) = __.RequestResource(fun () -> Channel<'T>.Init(id))
      member __.RequestDictionary<'T>() = __.RequestResource(fun () -> CloudDictionary<'T>.Init())
      member __.RequestAtom<'T>(id, init) = __.RequestResource(fun () -> Atom<'T>.Init(id, init))
  