anchor.diff:    /// `Job.queue`, `Proc.start`.
     val inline start: Job<unit> -> Job<unit>
   
  -  /// `startIgnore xJ` is equivalent to `Job.Ignore xJ |> start`.
  +  /// Creates a job that immediately starts running the given job as a separate
  +  /// concurrent job.  `startIgnore xJ` is equivalent to `Job.Ignore xJ |>
  +  /// start`.
     val startIgnore: Job<_> -> Job<unit>
   
     /// Creates a job that schedules the given job to be run as a separate
  
positive.code: #endif
    val inline tryIn: Job<'x> -> ('x -> #Job<'y>) -> (exn -> #Job<'y>) -> Job<'y>
  
    /// `tryInDelay u2xJ x2yJ e2yJ` is equivalent to `tryIn (delay u2xJ) x2yJ
    /// e2yJ`.
    val inline tryInDelay: (unit -> #Job<'x>) -> ('x -> #Job<'y>) -> (exn -> #Job<'y>) -> Job<'y>
  
    /// Implements the try-with exception handling construct for jobs.
  
negative.code: /// Operations on jobs.
  module Job =
    /// Operations on the global scheduler.
  #if DOC
    ///
    /// Note that in a typical program there should only be a few points (maybe
    /// just one) where jobs are started or run outside of job workflows.
  #endif
    module Global =
      /// Starts running the given job on the global scheduler, but does not wait
      /// for the job to finish.  Upon the failure or success of the job, one of
      /// the given actions is called once.
  #if DOC
      ///
      /// Note that using this function in a job workflow is not optimal and you
      /// should instead use `Job.start` with the desired exception handling
      /// construct (e.g. `Job.tryIn` or `Job.catch`).
  #endif
      val startWithActions: (exn -> unit) -> ('x -> unit) -> Job<'x> -> unit
  
      /// Starts running the given job on the global scheduler, but does not wait
      /// for the job to finish.  See also: `queue`, `server`.
  #if DOC
      ///
      /// Note that using this function in a job workflow is not optimal and you
      /// should use `Job.start` instead.
  #endif
      val inline start: Job<unit> -> unit
  
      /// Starts running the given job on the global scheduler, but does not wait
      /// for the job to finish.  `startIgnore xJ` is equivalent to `Job.Ignore xJ
      /// |> start`.
      val startIgnore: Job<_> -> unit
  
      /// 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 and then blocks the
  