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 fill: MVar<'x> -> 'x -> Job<unit>
  
    /// Creates an alternative that takes the value of the serialized variable and
    /// 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
  
negative.code:   /// just one) where jobs are started or run outside of job workflows.
  #endif
    module Global =
      /// Queues the job for execution on the global scheduler.  See also:
      /// `start`, `server`.
  #if DOC
      ///
      /// Note that using this function in a job workflow is not optimal and you
      /// should use `Job.queue` instead.
  #endif
      val inline queue:       Job<unit> -> unit
  
      /// Queues the job for execution on the global scheduler.  `queueIgnore xJ`
      /// is equivalent to `Job.Ignore xJ |> queue`.
      val queueIgnore: Job<_>    -> unit
  
      /// Like `Job.Global.start`, but the given job is known never to return
      /// normally, so the job can be spawned in an even more lightweight manner.
  #if DOC
      ///
      /// Note that using this function in a job workflow is not optimal and you
      /// should use `Job.server` instead.
  #endif
      val server:      Job<Void> -> unit
  
      /// Starts running the given job on the global scheduler, but does not wait
      /// for the job to finish.  See also: `queue`, `server`.
  