anchor.diff:  ///>      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
  
positive.code:   /// committed to.  This is the same as `afterJob` with the arguments flipped.
    val inline ( ^=>  ): Alt<'x> -> ('x -> #Job<'y>) -> Alt<'y>
  
    /// `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`.
    val ( ^=>. ): Alt<_>  ->         Job<'y>  -> Alt<'y>
  
    /// `xA ^->. y` is equivalent to `xA ^-> fun _ -> y`.
    val ( ^->. ): Alt<_>  ->             'y   -> Alt<'y>
  
    /// `xA ^->! e` is equivalent to `xA ^-> fun _ -> raise e`.
    val ( ^->! ): Alt<_>  ->             exn  -> Alt<_>
  
  
negative.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 >>= 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 >>= always (result y)`.
    val ( >>-.  ): Job<_>  ->             'y   ->     Job<'y>
  
    /// A memoizing version of `>>-.`.
  