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:                 else
                      doc.Value <- doc.Value - value
  
              do! writeQueue.Add((docKey, doc,etag, complete))
  
              return! wait 
          }
  
negative.code: 
          let result = 
              seq {
                  let doc = new MyCountingDoc()
                  let metadata = new Raven.Json.Linq.RavenJObject()
                  metadata.Add("Raven-Entity-Name", new RavenJValue("MyCountingDocs"))
                  let writeRequests = Seq.singleton {
                      DocumentKey = docKey
                      Document = lazy(RavenJObject.FromObject(doc))
                      Metadata = lazy(metadata)
                      Etag = Raven.Abstractions.Data.Etag.Empty }
                  yield (writeRequests, (fun _ -> async { () }))
              }
              |> BatchOperations.writeBatch documentStore 
              |> Async.RunSynchronously
  