anchor.diff:  /// `AutoResetEvent` using serialized variables:
   ///
   ///> type AutoResetEvent (init: bool) =
  -///>   let set = if init then mvarFull () else mvar ()
  -///>   let unset = if init then mvar () else mvarFull ()
  +///>   let set = if init then MVar (()) else MVar ()
  +///>   let unset = if init then MVar () else MVar (())
   ///>   member this.Set = unset <|> set >>= MVar.fill set
   ///>   member this.Wait = set ^=> MVar.fill unset
   ///
   /// The idea is to use two serialized variables to represent the state of the
   /// synchronization object.  At most one of the variables, representing the
   /// state of the synchronization object, is full at any time.
  -///
  -/// Note that `MVar` is a subtype of `Alt` and `xM :> Alt<'x>` is equivalent to
  -/// `MVar.take xM`.
  -type MVar<'x> :> Alt<'x>
  +type MVar<'x> =
  +  /// `MVar<'x>` is a subtype of `Alt<'x>` and `xM :> Alt<'x>` is equivalent to
  +  /// `MVar.take xM`.
  +  inherit Alt<'x>
  +
  +  /// Creates a new serialized variable that is initially empty.
  +  new: unit -> MVar<'x>
  +
  +  /// Creates a new serialized variable that initially contains the given value.
  +  new: 'x   -> MVar<'x>
   #endif
   
   /// Operations on serialized variables.
  
positive.code: /// is possible because write once variables do not support simple rendezvous
  /// like channels do.  When simple rendezvous is necessary, a channel should be
  /// used instead.
  ///
  /// Note that `IVar` is a subtype of `Promise` and `IVar.read xI` is equivalent
  /// to `xI :> Alt<'x>`.
  type IVar<'x> :> Promise<'x>
  #endif
  
  /// Operations on write once variables.
  
negative.code: /// simply not necessary.  However, when process objects are known to be needed,
  /// it is better to allocate them eagerly by directly starting processes using
  /// `Proc.start` or `Proc.queue`.
  type Proc =
    /// `Proc` is a subtype of `Alt<unit>` and `p :> Alt<unit>` is equivalent to
    /// `Proc.join p`.
    inherit Alt<unit>
  #endif
  
  /// Operations on processes.
  