anchor.diff:    ///>   upcast replyCh
     ///
     /// The client side operation just sends the negative acknowledgment to the
  -  /// server as a part of the request.  It is essential that a channel, rather
  -  /// than a write once variable, is used for the reply.  It is also a good idea
  -  /// to avoid blocking inside `withNack`, which is why an asynchronous send is
  -  /// used inside the client side operation.
  +  /// server as a part of the request.  It is essential that a synchronous
  +  /// rendezvous via a channel, rather than e.g. a write once variable, is used
  +  /// for the reply.  It is also important to avoid blocking inside `withNack`,
  +  /// which is why an asynchronous send is used inside the client side
  +  /// operation.
     ///
     /// Note that if an alternative created with `withNack` is not instantiated,
     /// then no negative acknowledgment is created.  For example, given an
  
positive.code: ////////////////////////////////////////////////////////////////////////////////
  
  #if DOC
  /// Represents a first-class synchronous operation.
  ///
  /// The inspiration for alternatives comes from the events of Concurrent ML.
  /// The term ''alternative'' was chosen, because the term ''event'' is already
  /// widely used in .Net.
  ///
  /// Simpler forms of selective synchronization exists in various languages.  For
  /// example, the occam language has an `alt` statement and the Go language has a
  /// `select` statement.  In Hopac and Concurrent ML, selective synchronous
  /// operations are not limited to primitive message passing operations (see
  /// `Ch.Alt.give` and `Ch.Alt.take`), but are instead first-class values (see
  /// `choose`) and can be extended with user-defined code (see `wrap` and
  /// `withNack`) allowing the encapsulation of concurrent protocols as selective
  /// synchronous operations.
  ///
  /// Note that `Alt` is a subtype of `Job`.  You can use an alternative in any
  /// context that requires a job and `xA >>= fun x -> ...` is equivalent to `pick
  
negative.code:   ///
    /// Here is a simple example of an operation encapsulated using `withNack`.
    /// The idea is that we have a server that maintains a counter.  Clients can
    /// request the server to increment the counter by a specific amount and
    /// return the incremented counter value.  We further want to make it so that
    /// in case the client does not commit to the operation, the counter in the
    /// server is not updated.
    ///
    /// Here is the server communication channel and the server loop:
    ///
  