anchor.diff:  
     /// Creates an alternative that constructs a query with a reply channel and a
     /// nack, sends it to the query channel and commits on taking the reply from
  -  /// the reply channel.
  +  /// the reply channel.  `*<+->` captures the most common use case of
  +  /// `Alt.withNackJob`.  See also: `*<-=>`.
  +#if DOC
  +  ///
  +  /// Here is the `incrementBy` function from the example in `Alt.withNackJob`
  +  /// expressed using `*<+->`:
  +  ///
  +  ///> let incrementBy n =
  +  ///>   counterServer *<+-> fun replyCh nack -> (n, nack, replyCh)
  +  ///
  +  /// Reference implementation:
  +  ///
  +  ///> let ( *<+-> ) qCh rCh2n2q = Alt.withNackJob <| fun nack ->
  +  ///>   let rCh = Ch<_> ()
  +  ///>   qCh *<+ rCh2n2q rCh nack >>-.
  +  ///>   rCh
  +#endif
     val inline ( *<+-> ): Ch<'q> -> (Ch<'r> -> Promise<unit> -> 'q) -> Alt<'r>
   
     /// Creates an alternative that constructs a query with a reply variable,
  -  /// commits on giving the query and reads the reply variable.
  +  /// commits on giving the query and reads the reply variable.  `*<-=>`
  +  /// captures the most common use case of `Alt.prepareFun`.  See also: `*<+->`.
  +#if DOC
  +  ///
  +  /// Reference implementation:
  +  ///
  +  ///> let ( *<-=> ) qCh rI2q = Alt.prepareFun <| fun () ->
  +  ///>   let rI = IVar<_> ()
  +  ///>   qCh *<- rI2q rI ^=>.
  +  ///>   rI
  +#endif
     val inline ( *<-=> ): Ch<'q> -> (IVar<'r> -> 'q) -> Alt<'r>
   
     /// Creates a job that writes to the given write once variable.  It is an
  
positive.code:   val raises: exn -> Alt<_>
  
    /// Creates an alternative that is computed at instantiation time with the
    /// given job.  See also: `prepareFun`, `withNackJob`.
  #if DOC
    ///
    /// `prepareJob` allows client-server protocols that do not require the server
  
negative.code:   val prepare: Job<#Alt<'x>> -> Alt<'x>
  
    /// Creates an alternative that is computed at instantiation time with the
    /// given thunk.  See also: `*<-=>`, `prepareJob`.
  #if DOC
    ///
    /// `prepareFun` is an optimized weaker form of `prepareJob` that can be used
    /// when no concurrent operations beyond the returned alternative are required
    /// by the encapsulated request protocol.
    ///
    /// Reference implementation:
    ///
  