anchor.diff:      module Con =
         /// Iterates the given job constructor over the given sequence, runs the
         /// constructed jobs as separate concurrent jobs and waits until all of
  -      /// the jobs have finished.
  +      /// the jobs have finished.  See also: `Con.iterJobIgnore`, `conIgnore`.
  +      ///
  +      /// Note that this is not optimal for fine-grained parallel execution.
         val inline iterJob: ('x -> #Job<unit>) -> seq<'x> -> Job<unit>
   
  -      /// `iterJobIgnore x2yJ xs` is equivalent to `iterJob (x2yJ >> Job.Ignore)
  -      /// xs`.
  +      /// `Con.iterJobIgnore x2yJ xs` is equivalent to `Con.iterJob (x2yJ >>
  +      /// Job.Ignore) xs`.
  +      ///
  +      /// Note that this is not optimal for fine-grained parallel execution.
         val iterJobIgnore: ('x -> #Job<_>) -> seq<'x> -> Job<unit>
   
         /// Iterates the given job constructor over the given sequence, runs the
         /// constructed jobs as separate concurrent jobs and waits until all of
  -      /// the jobs have finished collecting the results into a list.
  +      /// the jobs have finished collecting the results into a list.  See also:
  +      /// `Seq.mapJob`, `conCollect`.
  +      ///
  +      /// Note that this is not optimal for fine-grained parallel execution.
         val mapJob: ('x -> #Job<'y>) -> seq<'x> -> Job<ResizeArray<'y>>
   
     /// Operations for interfacing F# async operations with jobs.
  
positive.code:   /////////////////////////////////////////////////////////////////////////////
  
    /// Creates a job that runs all of the jobs in sequence and returns a list of
    /// the results.  See also: `seqIgnore`.
  #if DOC
    ///
    /// Reference implementation:
  
negative.code:   val seqIgnore: seq<#Job<_>> -> Job<unit>
  
    /// Creates a job that runs all of the jobs as separate concurrent jobs and
    /// returns a list of the results.  See also: `conIgnore`, `seqCollect`,
    /// `Seq.Con.mapJob`.
    ///
    /// Note that when multiple jobs raise exceptions, then the created job raises
    /// an `AggregateException`.
    ///
    /// Note that this is not optimal for fine-grained parallel execution.
    val conCollect: seq<#Job<'x>> -> Job<ResizeArray<'x>>
  
    /// Creates a job that runs all of the jobs as separate concurrent jobs and
    /// then waits for all of the jobs to finish.  The results of the jobs are
    /// ignored.  See also: `conCollect`, `seqIgnore`, `Seq.Con.iterJob`.
    ///
    /// Note that when multiple jobs raise exceptions, then the created job raises
    /// an `AggregateException`.
    ///
    /// Note that this is not optimal for fine-grained parallel execution.
    val conIgnore: seq<#Job<_>> -> Job<unit>
  
    /////////////////////////////////////////////////////////////////////////////
  