anchor.diff:                      if NotFound ex then return false else return raise ex
               }
           
  -        member this.ToEnumerable(): Local<seq<Collections.Generic.KeyValuePair<string,'T>>> = 
  +        member this.ToEnumerable(): Async<seq<Collections.Generic.KeyValuePair<string,'T>>> = 
               async {
                   let! entities = Table.readAll<FatEntity> client tableName
                   return entities
                          |> Seq.map (fun entity -> new KeyValuePair<_,_>(entity.PartitionKey, VagabondRegistry.Instance.Serializer.UnPickle<'T>(entity.GetPayload())))
  -            } |> Cloud.OfAsync
  +            }
           
           member this.TryAdd(key: string, value: 'T): Async<bool> = 
               async {
                   try
  -                    do! (this :> ICloudDictionary<'T>).Add(key, value)
  +                    do! (this :> CloudDictionary<'T>).Add(key, value)
                       return true
                   with ex ->
                       if Conflict ex then return false else return raise ex
  
positive.code:                 return e <> null
              }
          
          member this.Count: Local<int64> = Cloud.Raise(new NotSupportedException("Count property not supported."))
          
          member this.Size: Local<int64> = Cloud.Raise(new NotSupportedException("Size property not supported."))
  
          member this.Dispose(): Local<unit> = 
              async {
                  let! _ = client.GetTableReference(tableName).DeleteAsync()
                           |> Async.AwaitTask
                  return ()
              } |> Cloud.OfAsync
          
          member this.Id: string = tableName
          
  
negative.code:     [<OnDeserialized>]
      let _onDeserialized (_ : StreamingContext) =
          client <- Table.getClient(CloudStorageAccount.Parse connectionString)
  
      let getSeqAsync() = async {
          let! entities = Table.readAll<FatEntity> client tableName
          return entities
                  |> Seq.map (fun entity -> new KeyValuePair<_,_>(entity.PartitionKey, VagabondRegistry.Instance.Serializer.UnPickle<'T>(entity.GetPayload())))
      }
  
      let getSeq() = getSeqAsync() |> Async.RunSync
  
      interface seq<KeyValuePair<string,'T>> with
          member __.GetEnumerator() = getSeq().GetEnumerator() :> IEnumerator
          member __.GetEnumerator() = getSeq().GetEnumerator()
          
      interface CloudDictionary<'T> with
          member x.IsKnownCount: bool = false
          member x.IsMaterialized : bool = false
          member x.IsKnownSize: bool = false
          
          member this.Add(key: string, value : 'T): Async<unit> = 
  