anchor.diff:                  do! client.SendAsync(msg)
               }
           
  -        member x.EnqueueBatch(_messages: seq<'T>): Async<unit> = 
  -            raise <| new NotImplementedException()
  +        member x.EnqueueBatch(messages: seq<'T>): Async<unit> = 
  +            async {
  +                return!
  +                    messages
  +                    |> Seq.map (fun item ->
  +                        let bin = VagabondRegistry.Instance.Serializer.Pickle item
  +                        use ms = new MemoryStream(bin) in ms.Position <- 0L
  +                        new BrokeredMessage(ms))
  +                    |> client.SendBatchAsync
  +            }
           
           member x.TryDequeue(): Async<'T option> = 
  -            raise <| new NotImplementedException()
  +            async {
  +                let! (msg : BrokeredMessage) = client.ReceiveAsync()
  +                match msg with
  +                | null -> return None
  +                | msg ->
  +                    use stream = msg.GetBody<Stream>()
  +                    return Some(VagabondRegistry.Instance.Serializer.Deserialize<'T>(stream))
  +            }
           
           member x.Dequeue(?timeout: int): Async<'T> = 
               async {
  
positive.code: 
          member __.CreateQueue<'T> (_ : string) =
              async {
                  let queuePath = sprintf "channel_%s" <| guid()
                  let qd = new QueueDescription(queuePath)
                  qd.SupportOrdering <- true
                  qd.DefaultMessageTimeToLive <- TimeSpan.MaxValue
  
negative.code: 
      interface CloudQueue<'T> with
          member x.Id: string = queuePath
          member x.Count: Async<int64> =
              async {
                  let! queueDescription = nsClient.GetQueueAsync(queuePath)
                                          |> Async.AwaitTask
                  return queueDescription.MessageCount
              }
          
          member x.Enqueue(message: 'T): Async<unit> = 
              async {
  