anchor.diff:  /// compute results in parallel in regular patterns, combinators such as `<*>`,
   /// `Job.conCollect` and `Seq.Con.mapJob` may be easier to use and provide
   /// improved performance.
  -type Promise<'x> :> Alt<'x>
  +type Promise<'x> =
  +  /// `Promise<'x>` is a subtype of `Alt<'x>` and `xPr :> Alt<'x>` is equivalent
  +  /// to `Promise.read xPr`.
  +  inherit Alt<'x>
  +
  +  /// Creates a promise whose value is computed lazily with the given job when
  +  /// an attempt is made to read the promise.  Although the job is not started
  +  /// immediately, the effect is that the delayed job will be run as a separate
  +  /// job, which means it is possible to communicate with it as long the delayed
  +  /// job is started before trying to communicate with it.
  +  new: Job<'x> -> Promise<'x>
  +
  +  /// Creates a promise with the given value.
  +  new:     'x  -> Promise<'x>
  +
  +  /// Creates a promise with the given failure exception.
  +  new: exn     -> Promise<'x>
  +
   #endif
   
   /// Operations on promises.
  
positive.code: /// is possible because write once variables do not support simple rendezvous
  /// like channels do.  When simple rendezvous is necessary, a channel should be
  /// used instead.
  ///
  /// Note that `IVar` is a subtype of `Promise` and `IVar.read xI` is equivalent
  /// to `xI :> Alt<'x>`.
  type IVar<'x> :> Promise<'x>
  #endif
  
  /// Operations on write once variables.
  
negative.code: /// the arguments, negative acknowledgment token and a channel to the server and
  /// then synchronize using a `take` operation on the channel for the reply.  See
  /// `withNackJob` for an illustrative toy example.
  type Alt<'x> =
    /// `Alt<'x>` is a subtype of `Job<'x>`.  You can use an alternative in any
    /// context that requires a job.
    inherit Job<'x>
  #endif
  
  /// Operations on first-class synchronous operations or alternatives.
  