anchor.diff:    val create: unit -> Job<Ch<'x>>
   
     /// Creates an alternative that, at instantiation time, offers to give the
  -  /// given value on the given channel, and becomes available for picking when
  -  /// another job offers to take the value.
  +  /// given value on the given channel, and becomes available when another job
  +  /// offers to take the value.
     val inline give: Ch<'x> -> 'x -> Alt<unit>
   
     /// Creates an alternative that, at instantiation time, offers to take a value
  -  /// from another job on the given channel, and becomes available for picking
  -  /// when another job offers to give a value.
  +  /// from another job on the given channel, and becomes available when another
  +  /// job offers to give a value.
     val inline take: Ch<'x> -> Alt<'x>
   
     /// Creates a job that sends a value to another job on the given channel.  A
  
positive.code: #endif
    val withNack: (Promise<unit> -> #Job<#Alt<'x>>) -> Alt<'x>
  
    /// Creates an alternative that is available for picking when any one of the
    /// given alternatives is.  See also: `<|>?`.
    ///
    /// Note that `choose []` is equivalent to `never ()`.
  #if DOC
  
negative.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 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 available and
    /// the server can also abort the operation.
    ///
    /// Here is a simple example of an operation encapsulated using `withNack`.
  