anchor.diff:    /// committed to.  This is the same as `afterJob` with the arguments flipped.
     val inline ( ^=>  ): Alt<'x> -> ('x -> #Job<'y>) -> 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 ^-> x2y` is equivalent to `xA ^=> (x2y >> result)`.  This is the same
     /// as `afterFun` with the arguments flipped.
     val inline ( ^->  ): Alt<'x> -> ('x ->      'y)  -> Alt<'y>
   
  -  /// `xA ^=>. yJ` is equivalent to `xA ^=> fun _ -> yJ`.
  +  /// Creates an alternative which is committed to when the given alternative
  +  /// is committed to. Once committed, the job argument is executed and
  +  /// generates the result.
  +  ///
  +  /// `xA ^=>. yJ` is equivalent to `xA ^=> always yJ`.
     val ( ^=>. ): Alt<_>  ->         Job<'y>  -> Alt<'y>
   
  -  /// `xA ^->. y` is equivalent to `xA ^-> fun _ -> y`.
  +  /// Creates an alternative which is committed to when the given alternative
  +  /// is committed to. Once committed, the given value is used as the result.
  +  ///
  +  /// `xA ^->. y` is equivalent to `xA ^-> always y`.
     val ( ^->. ): Alt<_>  ->             'y   -> Alt<'y>
   
  +  /// Creates an alternative which is committed to when the alternative
  +  /// argument is committed to. Once committed, the given exception is raised.
  +  ///
     /// `xA ^->! e` is equivalent to `xA ^-> fun _ -> raise e`.
     val ( ^->! ): Alt<_>  ->             exn  -> Alt<_>
   
  
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
  