anchor.diff:    ///
     /// Reference implementation:
     ///
  -  ///> let modifyFun (x2xy: 'x -> 'x * 'y) (xM: MVar<'x>) =
  -  ///>   xM ^=> (x2xy >> fun (x, y) -> fill xM x >>-. y)
  -#endif
  -  val inline modifyFun: ('x ->      'x * 'y)  -> MVar<'x> -> Alt<'y>
  +  ///> let modifyJob (x2xyJ: 'x -> Job<'x * 'y>) (xM: MVar<'x>) =
  +  ///>   xM ^=> (x2xyJ >=> fun (x, y) -> fill xM x >>-. y)
  +#endif
  +  val inline modifyJob: ('x -> #Job<'x * 'y>) -> MVar<'x> -> Alt<'y>
   
     /// Creates an alternative that takes the value of the serialized variable and
  -  /// then fills the variable with the result of performing the given job.
  +  /// then fills the variable with the result of performing the given function.
     ///
     /// Note that this operation is not atomic as such.  However, it is a common
     /// programming pattern to make it so that only the job that has emptied an
  
positive.code:   /// equivalent to `Job.Ignore xJ |> whileDo u2b`.
    val inline whileDoIgnore: (unit -> bool) ->           Job<_>    -> Job<unit>
  
    /// `whenDo b uJ` is equivalent to `if b then uJ else Job.unit ()`.
    val inline whenDo: bool -> Job<unit> -> Job<unit>
  
  
negative.code:     val get: Promise<'x> -> 'x
  
    /// Creates a job that creates a promise, whose value is computed with the
    /// given job, which is scheduled to be run as a separate concurrent job.  See
    /// also: `start`, `Job.queue`.
    val queue: Job<'x> -> Job<Promise<'x>>
  
    /// Creates a job that creates a promise, whose value is computed with the
    /// given job, which is immediately started to run as a separate concurrent
    /// job.  See also: `queue`, `Job.queue`.
    val start: Job<'x> -> Job<Promise<'x>>
  
    /// Creates an alternative for reading the promise.  If the promise was
    /// delayed, it is started as a separate job.
  