anchor.diff:  
   type DocumentHandlerSet<'TKey, 'TDocument> = seq<('TKey * seq<DocumentHandler<'TDocument>>)>
   
  +type SubscriberEvent<'TContext> = {
  +    Event : obj
  +    Context : 'TContext
  +    StreamId : string
  +    EventNumber: int
  +}
  +
   [<CustomComparison>]
   [<CustomEquality>]
  -type DocumentProcessor<'TKey, 'TDocument> = {
  +type DocumentProcessor<'TKey, 'TDocument, 'TContext> = {
       ProcessorKey : string
       GetDocumentKey : 'TKey -> string
       EventTypes : seq<Type>
  -    Match: (obj -> DocumentHandlerSet<'TKey,'TDocument>)
  +    MatchingKeys: SubscriberEvent<'TContext> -> seq<'TKey>
  +    Process: 'TKey -> 'TDocument -> SubscriberEvent<'TContext> -> 'TDocument
       NewDocument : 'TKey -> 'TDocument
   }
   with
  -    override x.Equals(y) = (match y with :? DocumentProcessor<'TKey, 'TDocument> as y -> x.ProcessorKey = y.ProcessorKey | _ -> false)
  +    override x.Equals(y) = (match y with :? DocumentProcessor<'TKey, 'TDocument, 'TContext> as y -> x.ProcessorKey = y.ProcessorKey | _ -> false)
       override x.GetHashCode() = x.ProcessorKey.GetHashCode()
       interface System.IComparable with 
  -        member x.CompareTo y = x.ProcessorKey.CompareTo (y :?> DocumentProcessor<'TKey, 'TDocument>).ProcessorKey
  +        member x.CompareTo y = x.ProcessorKey.CompareTo (y :?> DocumentProcessor<'TKey, 'TDocument, 'TContext>).ProcessorKey
   
   //with 
   //    static member ToUntypedDocumentProcessor (x:DocumentProcessor<'TKey, 'TDocument>) =
  
positive.code:         let complete  = fun success -> async { tcs.SetResult(success) }
          (complete, Async.AwaitTask tcs.Task)
          
      let tryEvent (key : Guid, documentProcessor : DocumentProcessor<Guid,CurrentDoc>) events =
          async { 
              let docKey = documentProcessor.GetDocumentKey(key)
              
  
negative.code: 
              (newDoc, metadata, etag)
  
          let matcher (subscriberEvent : SubscriberEvent<EventContext>) =
              match subscriberEvent.Event with
              | :? (Guid * int) as event ->
                  event |> fst |> Seq.singleton
              | _ -> Seq.empty
  
          let processEvent key doc subscriberEvent = 
              match subscriberEvent.Event with
              | :? (Guid * int) as event ->
                  let (key, value) = event
                  processValue value doc
              | _ -> doc
  
          let processors : seq<DocumentProcessor<Guid,CurrentDoc, EventContext>> = seq {
              yield {
                  ProcessorKey = "Mine"
                  GetDocumentKey = (fun (key:Guid) -> "MyCountingDocs/" + key.ToString())
                  EventTypes = Seq.singleton typeof<int>
                  MatchingKeys = matcher
                  Process = processEvent
                  NewDocument = buildNewDoc
              }
          }
  
          let projector = new BulkRavenProjector<EventContext>(documentStore, processors)
  
          seq {
              yield async {
                  for event in myEvents do
                      do! projector.Enqueue event
                  do! projector.WaitAll()
              }
  
  