anchor.diff:              let port = int <| tokens.[1]
               new IPEndPoint(ipAddr, port)
   
  -        static let getPickler (p : FsPickler option) =
  -            match p with
  -            | None -> new FsPickler ()
  -            | Some p -> p
  -
           static member Create<'T>(behaviour : MailboxProcessor<'T> -> Async<unit>, ipEndPoint : IPEndPoint, ?pickler : FsPickler) =
               let mailbox = MailboxProcessor.Start behaviour
               new TcpActor<'T>(mailbox, ipEndPoint, ?pickler = pickler)
  
positive.code: 
                  let! (bytes : byte []) = stream.AsyncReadBytes()
  
                  let response =
                      try
                          let request = pickler.UnPickle<ServerRequest<'T>> bytes
  
                          match request with
                          | Post msg -> 
                              do mailbox.Post msg
                              Acknowledge
                          | PostWithReply rcc ->
                              let reply = rcc.PostWithReply mailbox
                              Reply reply
  
                      with e -> Fault e
  
                  let bytes = pickler.Pickle response
                  do! stream.AsyncWriteBytes bytes
  
              with e -> printfn "Server error: %A" e
  
  
negative.code:     // existentially pack reply channels
  
      type private IReplyChannelContainer<'T> =
          abstract PostWithReply : MailboxProcessor<'T> -> Async<obj>
  
      and private ReplyChannelContainer<'T, 'R>(msgB : AsyncReplyChannel<'R> -> 'T) =
          interface IReplyChannelContainer<'T> with
              member __.PostWithReply (mb : MailboxProcessor<'T>) = async {
                  let! r = mb.PostAndAsyncReply msgB
                  return r :> obj
              }
  
      type private ServerRequest<'T> =
          | Post of 'T
  