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:     ///>       Job.result x
      ///>   loop x
  #endif
      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>
  
      /// Operations for processing sequences using concurrent jobs.
      module Con =
  
negative.code:   /// Immediate or non-workflow operations on write once variables.
    module Now =
      /// Creates a new write once variable.
      val inline create:        unit -> IVar<'x>
  
      /// Creates a new write once variable with the given value.
      val inline createFull:    'x   -> IVar<'x>
  
      /// Creates a new write once variable with the given failure exception.
      val inline createFailure: exn  -> IVar<'x>
  
      /// Returns true iff the given write once variable has already been filled
      /// (either with a value or with a failure).
  