anchor.diff:  
     /// 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:
  -    ///
  -    ///> 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>>
  -
       /// Sequentially folds the job constructor over the given sequence and
       /// returns the result of the fold.
   #if DOC
  
positive.code:   /// Immediate or non-workflow operations on serialized variables.
    module Now =
      /// Creates a new serialized variable that is initially empty.
      val inline create: unit -> MVar<'x>
  
      /// Creates a new serialized variable that initially contains the given
      /// value.
      val inline createFull: 'x -> MVar<'x>
  
    /// Creates a job that creates a new serialized variable that is initially
    /// empty.
  
negative.code:   /// constructed job with `delay` and avoiding unnecessary `delay` operations
    /// can improve performance.
  #endif
    val inline delay:     (unit -> #Job<'y>)            -> Job<'y>
  
    /// Creates a job that invokes the given thunk to compute the result of the
    /// job.  `thunk u2x` is equivalent to `result () >>- u2x`.
    val inline thunk:     (unit ->      'y)             -> Job<'y>
  
    /// `join xJJ` is equivalent to `bind id xJJ`.
    val inline join: Job<#Job<'x>> -> Job<'x>
  
    /// Creates a job that immediately terminates the current job.  See also:
    /// `startWithFinalizer`.
  