anchor.diff:  #endif
     module Async =
       /// Creates a job that starts the given async operation and then waits until
  -    /// the operation finishes.
  +    /// the operation finishes.  See also: `toJobOn`, `toAlt`, `toAltOn`.
   #if DOC
       ///
       /// The async operation will be started on a Hopac worker thread, which
       /// means that the async operation will continue on the thread pool.
       /// Consider whether you need to call `Async.SwitchToContext` or some other
       /// thread or synchronization context switching async operation in your
  -    /// async operation.  See also: `toJobOn`, `toAlt`, `toAltOn`.
  +    /// async operation.
   #endif
       val toJob: Async<'x> -> Job<'x>
   
  
positive.code: #endif
      val inline iterJob: ('x -> #Job<unit>) -> seq<'x> -> Job<unit>
  
      /// `iterJobIgnore x2yJ xs` is equivalent to `iterJob (x2yJ >> Job.Ignore)
      /// xs`.
      val iterJobIgnore: ('x -> #Job<_>) -> seq<'x> -> Job<unit>
  
      /// Sequentially maps the given job constructor to the elements of the
      /// sequence and returns a list of the results.
  #if DOC
      ///
      /// Reference implementation:
  
negative.code:     /// xs`.
      val inline iterJob: ('x -> #Job<unit>) -> array<'x> -> Job<unit>
  
      /// `Array.iterJobIgnore x2yJ xs` is equivalent to `Array.iterJob (x2yJ >>
      /// Job.Ignore) xs`.
      val iterJobIgnore: ('x -> #Job<_>) -> array<'x> -> Job<unit>
  
    /// Operations for processing sequences with jobs.
    module Seq =
      /// Sequentially iterates the given job constructor over the given sequence.
      /// See also: `Seq.iterJobIgnore`, `Seq.Con.iterJob`, `seqIgnore`,
      /// `Array.mapJob`.
  #if DOC
      ///
      /// Reference implementation:
  