anchor.diff:    /// as the global wall-clock timer.
     val create: Create -> Scheduler
   
  +  /// Queues the given job for execution on the scheduler.
  +  ///
  +  /// Note that using this function in a job workflow is not optimal and you
  +  /// should use `Job.queue` instead.
  +  val inline queue:       Scheduler -> Job<unit> -> unit
  +
  +  /// `queueIgnore xJ` is equivalent to `Job.Ignore xJ |> queue`.
  +  val queueIgnore: Scheduler -> Job<_>    -> unit
  +
  +  /// Like `Scheduler.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:      Scheduler -> Job<Void> -> unit
  +
  +  /// Starts running the given job, but does not wait for the job to finish.
  +  ///
  +  /// Note that using this function in a job workflow is not optimal and you
  +  /// should use `Job.start` instead.
  +  val inline start:       Scheduler -> Job<unit> -> unit
  +
  +  /// `startIgnore xJ` is equivalent to `Job.Ignore xJ |> start`.
  +  val startIgnore: Scheduler -> Job<_>    -> unit
  +
     /// Starts running the given job, 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.  See also: `abort`.
  
positive.code:   ///>    <| Job.thunk u2u
  #endif
    val tryFinallyFun: Alt<'x> -> (unit -> unit) -> Alt<'x>
  
    /// Implements a variation of the `try-finally` exception handling construct
    /// for alternatives.  The given action, specified as a job, is executed after
    /// the alternative has been committed to, whether the alternative fails or
    /// completes successfully.  Note that the action is not executed in case the
    /// alternative is not committed to.  Use `withNackJob` to attach the action
    /// to the non-committed case.
  #if DOC
    ///
    /// Reference implementation:
    ///
    ///> let tryFinallyJob xA uJ =
    ///>   tryIn xA
    ///>    <| fun x -> uJ >>-. x
    ///>    <| fun e -> uJ >>-! e
  #endif
    val tryFinallyJob: Alt<'x> ->      Job<unit> -> Alt<'x>
  
    //# Debugging
  
  
negative.code:   /// Creates a job that creates a new mutual exclusion lock.
    val create: unit -> Job<Lock>
  
    /// Creates a job that runs the given job so that the lock is held during the
    /// execution of the given job.
    val inline duringJob: Lock ->      Job<'x> -> Job<'x>
  
    /// Creates a job that calls the given function so that the lock is held
    /// during the execution of the function.
    val inline duringFun: Lock -> (unit -> 'x) -> Job<'x>
  
  ////////////////////////////////////////////////////////////////////////////////
  
  