anchor.diff:  module Infixes =
     /// Creates an alternative that, at instantiation time, offers to give the
     /// given value on the given channel, and becomes available when another job
  -  /// offers to take the value.  `xCh <-? x` is equivalent to `Ch.Alt.give xCh
  -  /// x`.
  +  /// offers to take the value.  `xCh <-- x` is equivalent to `Ch.give xCh x`.
     val inline (<--): Ch<'x> -> 'x -> Alt<unit>
   
     /// Creates a job that sends a value to another job on the given channel.  A
  
positive.code: /// state of the synchronization object, is full at any time.
  ///
  /// Note that `MVar` is a subtype of `Alt` and `xM :> Alt<'x>` is equivalent to
  /// `MVar.Alt.take xM`.
  type MVar<'x> :> Alt<'x>
  #endif
  
  
negative.code: /// example, the occam language has an `alt` statement, the Go language has a
  /// `select` statement and Clojure's core.async has an `alt` function.  In Hopac
  /// and Concurrent ML, selective synchronous operations are not limited to
  /// primitive message passing operations (see `Ch.give` and `Ch.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.
  ///
  