anchor.diff:  
                   let! (bytes : byte []) = stream.AsyncReadBytes()
   
  -                let response =
  -                    try
  -                        let request = pickler.UnPickle<ServerRequest<'T>> bytes
  +                let respond (r : ServerResponse) = 
  +                    async { let bytes = pickler.Pickle r in do! stream.AsyncWriteBytes bytes }
   
  -                        match request with
  -                        | Post msg -> 
  -                            do mailbox.Post msg
  -                            Acknowledge
  -                        | PostWithReply rcc ->
  -                            let reply = rcc.PostWithReply mailbox
  -                            Reply reply
  +                try
  +                    let request = pickler.UnPickle<ServerRequest<'T>> bytes
   
  -                    with e -> Fault e
  -
  -                let bytes = pickler.Pickle response
  -                do! stream.AsyncWriteBytes bytes
  +                    match request with
  +                    | Post msg -> 
  +                        do mailbox.Post msg
  +                        do! respond Acknowledge
  +                    | PostWithReply rcc ->
  +                        let! reply = rcc.PostWithReply mailbox
  +                        do! respond <| Reply reply
  +                with e -> do! respond <| Fault e
   
               with e -> printfn "Server error: %A" e
   
  
positive.code:             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)
  
negative.code: 
      type AsyncBuilder with
          member __.Bind(f : Task<'T>, g : 'T -> Async<'S>) = __.Bind(Async.AwaitTask f, g)
          member __.Bind(f : Task, g : unit -> Async<'S>) = __.Bind(f.ContinueWith ignore, g)
  
      type Stream with
          member s.AsyncWriteBytes (bytes : byte []) =
  