anchor.diff:      let writeBatch _ docs = async {
           let originalDocMap = 
               docs
  -            |> Seq.map (fun (key, doc, _, callback) -> (key, (doc, callback)))
  +            |> Seq.collect (fun (writeRequests, callback) -> 
  +                writeRequests
  +                |> Seq.map(fun { DocumentKey = key; Document = document } ->
  +                    let document = document.Force()
  +                    (key, (document, callback))
  +                )
  +            )
               |> Map.ofSeq
   
           let! result = BatchOperations.writeBatch documentStore docs
  
positive.code: 
          let result = 
              seq {
                  yield (docKey, new MyCountingDoc(), null, (fun _ -> async { () }))
              }
              |> BatchOperations.writeBatch documentStore 
              |> Async.RunSynchronously
  
negative.code: open Raven.Json.Linq
  
  module BatchOperations =
      let buildPutCommand (writeRequest:DocumentWriteRequest) =
          let cmd = new PutCommandData()
          cmd.Document <- writeRequest.Document.Force()
          cmd.Key <- writeRequest.DocumentKey
          cmd.Etag <- writeRequest.Etag
  
          cmd.Metadata <- writeRequest.Metadata.Force()
          cmd
          
      let writeBatch (documentStore : Raven.Client.IDocumentStore) (docs:seq<BatchWrite>) = async {
          try 
              let! batchResult = 
                  docs
                  |> Seq.collect (fst >> Seq.map buildPutCommand)
                  |> Seq.cast<ICommandData>
                  |> Array.ofSeq
                  |> documentStore.AsyncDatabaseCommands.BatchAsync
  