anchor.diff:              let mlock = new obj()
               let evtTrigger = new Event<_,_>()
               return { Post = Internal.post mlock clock evtTrigger expire evts
  -                     Read = Internal.read' evts
  +                     Read = Internal.read' mlock evts
                        Clear = Internal.dropAll mlock evts
                        AwaitMail = Internal.awaitMail evtTrigger
                      }
  -        }        
  +        }
  +
  +    // Reads from an mailbox synchronized
  +    let inline readSync (mb : Mailbox<_>) = mb.Read ()  |> Feed.discardFuture
   
       /// Post an event to a mailbox
  -    let post evt (mb : Mailbox<_>) = mb.Post evt
  +    let postSync evt (mb : Mailbox<_>) = mb.Post evt
  +        
  +    let post evt (mb : Mailbox<_>) = async { return mb.Post evt }
  +    
   
       /// Post an event to many mailboxes
       let postMany evt mbs = 
  
positive.code:             | _ -> m := (Feed.Internal.unsafePush time evt inc, Feed.empty)
              trigger.Trigger(null, null)
                      
          let post mLock clock trigger expire evts evt : Async<unit> =
              async {
                  let! time = Clock.now clock
                  return lock mLock (push' time evt trigger expire evts)
              }
  
          let dropAll mLock (evts : Ref<Feed<'e> * Feed<'e>>) =
              async { return lock mLock (fun () -> evts := (Feed.empty, Feed.empty)) }
  
negative.code:         
          type MailTrigger = delegate of obj * EventArgs -> unit
  
          let inline read' mLock (m : Ref<Feed<'e> * Feed<'e>>) () =
              let (inc, out) = lock mLock (fun _ -> !m)
              Feed.combine inc out
  
          let inline push' time evt (trigger : Event<MailTrigger, EventArgs>) (expire : Expire)  (m : Ref<Feed<'e> * Feed<'e>>) : unit =
              let (inc, out) = !m
              match expire, Feed.tryHead (Feed.time out) with
              | After _, None -> 
  