anchor.diff:    /// operation never blocks.
     val inline send: Mailbox<'x> -> 'x -> Job<unit>
   
  -  /// Creates an alternative that becomes available for picking when the mailbox
  -  /// contains at least one value and, if committed to, takes a value from the
  -  /// mailbox.
  +  /// Creates an alternative that becomes available when the mailbox contains at
  +  /// least one value and, if committed to, takes a value from the mailbox.
     val inline take: Mailbox<'x> -> Alt<'x>
   
   ////////////////////////////////////////////////////////////////////////////////
  
positive.code:   /// `withNack` allows client-server protocols that do require the server to be
    /// notified when the client aborts the transaction to be encapsulated as
    /// selective operations.  The negative acknowledgment alternative will be
    /// available for picking in case some other instantiated alternative involved
    /// in the choice is committed to instead.
    ///
    /// Like `guard`, `withNack` is typically used to encapsulate the client side
    /// operation of a concurrent protocol.  The client side operation typically
    /// constructs a request, containing the negative acknowledgment alternative,
    /// sends it to a server and then returns an alternative that waits for a
    /// rendezvous with the server.  In case the client later commits to some
    /// other alternative, the negative acknowledgment token becomes pickable and
    /// the server can also abort the operation.
    ///
    /// Here is a simple example of an operation encapsulated using `withNack`.
  
negative.code: #endif
    val inline read: MVar<'x> -> Alt<'x>
  
    /// Creates an alternative that becomes available when the variable contains a
    /// value and, if committed to, takes the value from the variable.
    val inline take: MVar<'x> -> Alt<'x>
  
  ////////////////////////////////////////////////////////////////////////////////
  