anchor.diff:  #endif
     val inline queue: Job<unit> -> Job<unit>
   
  -  /// `queueIgnore xJ` is equivalent to `Job.Ignore xJ |> queue`.
  +  /// 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>
   
  -  /// Like `Job.start`, but the given job is known never to return normally, so
  -  /// the job can be spawned in an even more lightweight manner.
  +  /// 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>
   
  -  /// `Job.startWithFinalizer finalizerJ uJ` is like `Job.start uJ`, but
  -  /// attaches a finalizer to the started job.  The finalizer job is started as
  -  /// a separate job in case the started job does not return succesfully or
  -  /// raise an exception and is garbage collected.  If the job either returns
  -  /// normally or raises an exception, the finalizer job is not started.  See
  -  /// also: `Proc`.
  +  /// Creates a job that immediately starts running the given job as a separate
  +  /// concurrent job like `start`, but also attaches a finalizer to the started
  +  /// job.  The finalizer job is started as a separate job in case the started
  +  /// job does not return succesfully or raise an exception and is garbage
  +  /// collected.  If the job either returns normally or raises an exception, the
  +  /// finalizer job is not started.  See also: `Proc`.
   #if DOC
     ///
     /// When a job in Hopac is aborted (see `abort`) or is, for example, blocked
  
positive.code:   /// job.  `thunk u2x` is equivalent to `result () |>> u2x`.
    val inline thunk: (unit -> 'x) -> Job<'x>
  
    /// `Ignore xJ` is equivalent to `xJ |>> fun _ -> ()`.
    val Ignore: Job<_> -> Job<unit>
  
    /////////////////////////////////////////////////////////////////////////////
  
negative.code:   /// `Job.queue`, `Proc.start`.
    val inline start: Job<unit> -> Job<unit>
  
    /// 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
  