anchor.diff:    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
  +  /// second job.  `xJ >>=. yJ` is equivalent to `xJ >>= always yJ`.
     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
  +  /// `xJ >>-. y` is an optimized version of `xJ >>= always (result y)`.
     val ( >>-.  ): Job<_>  ->             'y   ->     Job<'y>
   
     /// A memoizing version of `>>-.`.
  
positive.code:   /// version of `never ()`.
    val  inline zero: unit -> Alt<unit>
  
    /// `Ignore xA` is equivalent to `xA ^-> fun _ -> ()`.
    val Ignore: Alt<_> -> Alt<unit>
  
    //# Before actions
  
negative.code: ///>      Ch<_>  Latch   Mailbox<_>  MVar<_>  Proc   Promise<_>
  ///>                                                     |
  ///>                                                   IVar<_>
  ///
  /// Parts of the documentation will refer to certain functions that are not
  /// provided as part of the library, but are defined as follows:
  ///
  ///> let always x _ = x
  namespace Hopac
  
  open System.Threading
  