anchor.diff:      val run: Job<'x> -> 'x
   
     //# Spawning jobs
  +
  +  /// Creates a job that schedules the given job to be run as a separate
  +  /// concurrent job.  Use `Promise.queue` if you need to be able to get the
  +  /// result.  See also: `Proc.queue`.
  +#if DOC
  +  ///
  +  /// The difference between `start` and `queue` is which job, the current job,
  +  /// or the new job, is immediately given control.  `start` queues the current
  +  /// job, while `queue` queues the new job.  `start` has slightly lower
  +  /// overhead than `queue` and is likely to be faster in cases where the new
  +  /// job blocks immediately.
  +  ///
  +  /// For best performance the choice of which operation to use, `start` or
  +  /// `queue`, depends on the critical path of your system.  It is generally
  +  /// preferable to keep control in the job that is on the critical path.
  +#endif
  +  val inline queue:       Job<unit> -> Job<unit>
  +
  +  /// Creates a job that schedules the given job to be run as a separate
  +  /// concurrent job.  `queueIgnore xJ` is equivalent to `Job.Ignore xJ |>
  +  /// queue`.
  +  val queueIgnore: Job<_>    -> Job<unit>
  +
  +  /// Creates a job that immediately starts running the given job as a separate
  +  /// concurrent job like `start`, but the given job is known never to return
  +  /// normally, so the job can be spawned in an even more lightweight manner.
  +  val server:      Job<Void> -> Job<unit>
   
     /// Creates a job that immediately starts running the given job as a separate
     /// concurrent job.  Use `Promise.start` if you need to be able to get the
  
positive.code:   val inline tryWithDelay: (unit -> #Job<'x>) -> (exn -> #Job<'x>) -> Job<'x>
  
    /// Implements a variation of the `try-finally` exception handling construct
    /// for jobs.  The given action, specified as a function, is executed after
    /// the job has been run, whether it fails or completes successfully.
  #if DOC
  
negative.code:     val inline bind: (uint64 -> #Job<'x>) -> Job<'x>
  
      /// `map r2x` is equivalent to `bind (r2x >> result)`.
      val  inline map: (uint64 ->      'x)  -> Job<'x>
  
      /// Returns a job that generates a pseudo random 64-bit unsigned integer.
      /// `get ()` is equivalent to `bind result`.
  