anchor.diff:      ///>       Job.result x
       ///>   loop x
   #endif
  -    val foldJob:           ('x -> 'y -> #Job<'x>) -> 'x -> seq<'y> -> Job<'x>
  +    val foldJob:     ('x -> 'y -> #Job<'x>) -> 'x -> seq<'y> -> Job<'x>
   
       /// `foldFromJob x x2y2xJ ys` is equivalent to `foldJob x2y2xJ x ys` and is
       /// often syntactically more convenient.
  -    val inline foldFromJob: 'x -> ('x -> 'y -> #Job<'x>)       -> seq<'y> -> Job<'x>
  +    val inline foldFromJob: 'x -> ('x -> 'y -> #Job<'x>) -> seq<'y> -> Job<'x>
  +
  +    /// Sequentially iterates the given job constructor over the given sequence.
  +    /// See also: `Seq.iterJobIgnore`, `Seq.Con.iterJob`, `seqIgnore`,
  +    /// `Array.mapJob`.
  +#if DOC
  +    ///
  +    /// Reference implementation:
  +    ///
  +    ///> let iterJob x2uJ (xs: seq<'x>) = Job.delay <| fun () ->
  +    ///>   Job.using <| xs.GetEnumerator () <| fun xs ->
  +    ///>   Job.whileDoDelay xs.MoveNext <| fun () ->
  +    ///>     x2uJ xs.Current
  +#endif
  +    val inline iterJob:       ('x -> #Job<unit>) -> seq<'x> -> Job<unit>
  +
  +    /// `Seq.iterJobIgnore x2yJ xs` is equivalent to `Seq.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.  See also: `seqCollect`,
  +    /// `Seq.Con.mapJob`, `Array.mapJob`.
  +#if DOC
  +    ///
  +    /// Reference implementation:
  +    ///
  +    ///> let mapJob x2yJ (xs: seq<'x>) = Job.delay <| fun () ->
  +    ///>   let ys = ResizeArray<_>()
  +    ///>   Job.using <| xs.GetEnumerator () <| fun xs ->
  +    ///>   Job.whileDoDelay xs.MoveNext <| fun () ->
  +    ///>         x2yJ xs.Current >>- ys.Add
  +    ///>   >>-. ys
  +#endif
  +    val mapJob: ('x -> #Job<'y>) -> seq<'x> -> Job<ResizeArray<'y>>
   
       /// Operations for processing sequences using concurrent jobs.
       module Con =
  
positive.code: #endif
    val abort: unit -> Job<_>
  
    //# Exception handling
  
    /// Creates a job that has the effect of raising the specified exception.
  
negative.code: 
    //# Basic jobs
  
    /// Creates a job with the given result.  See also: `lift`, `thunk`, `unit`.
    val result: 'x   -> Job<'x>
  
    /// Returns a job that does nothing and returns `()`.  `unit ()` is an
    /// optimized version of `result ()`.
    val   inline unit: unit -> Job<unit>
  
    /// Creates a job that first runs the given job and then passes the result of
    /// that job to the given function to build another job which will then be
    /// run.  This is the same as `>>=` with the arguments flipped.
    val inline bind:      ('x   -> #Job<'y>) -> Job<'x> -> Job<'y>
  
    /// Creates a job that calls the given function with the given value to build
    /// a job that will then be run.  `delayWith x2yJ x` is equivalent to `result
    /// x >>= x2yJ`.
    val inline delayWith: ('x   -> #Job<'y>) ->     'x  -> Job<'y>
  
    /// Creates a job that runs the given job and maps the result of the job with
    /// the given function.  This is the same as `>>-` with the arguments flipped.
    val inline map:       ('x   ->      'y)  -> Job<'x> -> Job<'y>
  
    /// Creates a job that calls the given function with the given value to
    /// compute the result of the job.  `lift x2y x` is equivalent to `result x
    /// >>- x2y`.  Note that `x2y x |> result` is not the same.
    val inline lift:      ('x   ->      'y)  ->     'x  -> Job<'y>
  
    /// Creates a job that calls the given function to build a job that will then
    /// be run.  `delay u2xJ` is equivalent to `result () >>= u2xJ`.
  #if DOC
  