anchor.diff:  /// annotate bind expressions to resolve the ambiguity.
   ///
   /// The types of the operations in the `MonadBuilder` may, at first glance, seem
  -/// complicated.  Essentially the covariant positions in signature are wrapped
  -/// with the `Job<_>` type constructor to make it possible to use lightweight
  -/// threads.  In a language with built-in lightweight threads this would be
  -/// unnecessary.  Reading the signature by mentally replacing every `Job<'x>`
  -/// with just `'x`, the signature should become clear.
  +/// complicated.  Essentially the covariant positions in the signature are
  +/// wrapped with the `Job<_>` type constructor to make it possible to use
  +/// lightweight threads.  In a language with built-in lightweight threads this
  +/// would be unnecessary.  Reading the signature by mentally replacing every
  +/// `Job<'x>` with just `'x`, the signature should become clear.
   #endif
   type EmbeddedJob<'x> = struct
       val Job: Job<'x>
  
positive.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.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.
  ///
  
negative.code: 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.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
  