anchor.diff:      /// be run.  This is the same as `bind` with the arguments flipped.
       val inline (>>=): Job<'x> -> ('x -> #Job<'y>) -> Job<'y>
   
  -    /// `(x2yJ >=> y2zJ) x` is equivalent to `x2yJ x >>= y2zJ`.
  +    /// Creates a job that is the composition of the given two jobs.  `(x2yJ >=>
  +    /// y2zJ) x` is equivalent to `x2yJ x >>= y2zJ` and is much like the `>>`
  +    /// operator on ordinary functions.
       val inline (>=>): ('x -> #Job<'y>) -> ('y -> #Job<'z>) -> 'x -> Job<'z>
   
       /// Creates a job that runs the given two jobs and returns the result of the
  
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:   /// Implements a variation of the `try-finally` exception handling construct
    /// for jobs.  The given action, specified as a job, is executed after the job
    /// has been run, whether it fails or completes successfully.
  #if DOC
    ///
    /// Note that the workflow notation of F# does not support this operation.  It
    /// only supports the weaker `tryFinallyFun` operation.
    ///
    /// Reference implementation:
    ///
  