anchor.diff:    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.
  +  /// 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.
  -#if DOC
  +  /// ignored.  See also: `conCollect`, `seqIgnore`, `Seq.Con.iterJob`.
     ///
     /// Note that when multiple jobs raise exceptions, then the created job raises
     /// an `AggregateException`.
  -#endif
  +  ///
  +  /// Note that this is not optimal for fine-grained parallel execution.
     val conIgnore: seq<#Job<_>> -> Job<unit>
   
     /////////////////////////////////////////////////////////////////////////////
  
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:   /////////////////////////////////////////////////////////////////////////////
  
    /// Creates a job that runs all of the jobs in sequence and returns a list of
    /// the results.  See also: `seqIgnore`, `conCollect`, `Seq.mapJob`.
  #if DOC
    ///
    /// Reference implementation:
  