anchor.diff:      /// Perform an update on the current state asynchronously
       member __.UpdateAsync fn = stateManager.PostAndAsyncReply (fun c -> Update(fn, c))    
   
  -    interface IObservable<'TModel> with
  +    interface IObservable<'a> with
           member __.Subscribe obs = (signal :> IObservable<_>).Subscribe obs
       interface ITracksDependents with
           member __.Track dep = (signal :> ITracksDependents).Track dep 
  
positive.code:     interface IDependent with
          member __.UpdateDirtyFlag v = (signal :> IDependent).UpdateDirtyFlag v
          member __.HasDependencies with get() = (signal :> IDependent).HasDependencies
      interface ISignal<'TModel> with
          member __.Value with get() = signal.Value
  
      interface IMutatable<'TModel> with
          member this.Value with get() = signal.Value and set(v) = this.Set(v) |> ignore
  
      interface IAtomicMutatable<'TModel> with
          member this.Update f = this.Update f
  
      interface IAsyncMutatable<'TModel> with
          member this.UpdateAsync fn = this.UpdateAsync fn
          member this.GetAsync () = this.GetAsync ()
          member this.SetAsync v = this.SetAsync v
  
negative.code: 
  // The messages we allow for manipulation of our state
  [<NoComparison>]
  type private PostMessage<'a> =
      | Get of AsyncReplyChannel<'a>                                  
      | Set of 'a * AsyncReplyChannel<'a>
      | Update of ('a -> 'a) * AsyncReplyChannel<'a>
  
  /// Type which manages state internally using a mailbox
  type AsyncMutable<'a> (initialState : 'a) =
      // Provide a mechanism to publish changes to our state as an observable
      // Note that we could have used a mutable here, but that would effectively
      // "duplicate state"
  