anchor.diff:    /// version of `never ()`.
     val  inline zero: unit -> Alt<unit>
   
  -  /// `Ignore xA` is equivalent to `xA ^-> fun _ -> ()`.
  +  /// `Ignore xA` is equivalent to `xA ^-> always ()`.
     val Ignore: Alt<_> -> Alt<unit>
   
     //# Before actions
  
positive.code:   val inline ( >>-*  ): Job<'x> -> ('x ->      'y)  -> Promise<'y>
  
    /// Creates a job that runs the given two jobs and returns the result of the
    /// second job.  `xJ >>=. yJ` is equivalent to `xJ >>= fun _ -> yJ`.
  #if DOC
    ///
    /// Note that `yJ` is evaluated eagerly. Any side effects from the
    /// evaluation of `yJ` to a value are not delayed.
    ///
    /// For example:
    /// `Job.thunk (fun () -> printf "hello") >>=. Job.result (printf "world")`
    ///  will print "worldhello".
    ///
    /// To delay evaluation of `yJ`, use the full form `xJ >>= fun _ -> yJ`.
  #endif
    val ( >>=.  ): Job<_>  ->         Job<'y>  ->     Job<'y>
  
    /// A memoizing version of `>>=.`.
    val inline ( >>=*. ): Job<_>  ->         Job<'y>  -> Promise<'y>
  
    /// Creates a job that runs the given job and then returns the given value.
    /// `xJ >>-. y` is an optimized version of `xJ >>= fun _ -> result y`.
  #if DOC
    ///
    /// Note that `y` is evaluated eagerly. Any side effects from the
    /// evaluation of `y` to a value are not delayed.
    ///
    /// For example:
    /// `Job.thunk (fun () -> printf "hello") >>-. printf "world"`
    /// will print "worldhello".
    ///
    /// To delay evaluation of `y`, use the full form `xJ >>- fun _ -> y`.
  #endif
    val ( >>-.  ): Job<_>  ->             'y   ->     Job<'y>
  
    /// A memoizing version of `>>-.`.
  
negative.code: #endif
    val inline afterJob: ('x -> #Job<'y>) -> Alt<'x> -> Alt<'y>
  
    /// Creates an alternative which is committed to when the given alternative
    /// is committed to. Once committed, the given alternative's result is mapped
    /// using the given function, providing the final result.
    ///
    /// `xA |> afterFun x2y` is equivalent to `xA |> afterJob (x2y >> result)`.
    /// This is the same as `^->` with the arguments flipped.
    val inline afterFun: ('x ->      'y)  -> Alt<'x> -> Alt<'y>
  