anchor.diff:    ///>   paranoid xCh
   #endif
     val inline once: 'x -> Alt<'x>
  +
  +  /// Creates an alternative that is never available.
  +  ///
  +  /// Note that synchronizing on `never ()`, without other alternatives, is
  +  /// equivalent to performing `abort ()`.
  +  val inline never: unit -> Alt<'x>
  +
  +  /// Returns an alternative that is never available.  `zero ()` is an optimized
  +  /// version of `never ()`.
  +  val  inline zero: unit -> Alt<unit>
  +
  +  /// `Ignore xA` is equivalent to `xA ^-> fun _ -> ()`.
  +  val Ignore: Alt<_> -> Alt<unit>
   
     //# Before actions
   
  
positive.code:   ///
    /// Note that when there are alternatives immediately available in a choice,
    /// the first such alternative will be committed to.
    val inline always: 'x -> Alt<'x>
  
    /// Returns an alternative that is always available and results in the unit
    /// value.  `unit ()` is an optimized version of `always ()`.
    val inline unit: unit -> Alt<unit>
  
    /// Creates an alternative that is never available.
    ///
    /// Note that synchronizing on `never ()`, without other alternatives, is
    /// equivalent to performing `abort ()`.
    val inline never: unit -> Alt<'x>
  
    /// Returns an alternative that is never available.  `zero ()` is an optimized
    /// version of `never ()`.
    val inline zero: unit -> Alt<unit>
  
    /// Returns an alternative that can be committed to once and that produces the
    /// given value.
  
negative.code:   /// Note that this is not optimal for fine-grained parallel execution.
    val conIgnore: seq<#Job<_>> -> Job<unit>
  
    //# Interop
  
    /// Creates a job that performs the asynchronous operation defined by the
    /// given pair of begin and end operations.
  