anchor.diff:          | _ -> None
   
       let (|Abstract|_|) (m : MethodInfo) = if m.IsAbstract then Some() else None
  +    let (|Virtual|_|) (m : MethodInfo) = if m.IsVirtual then Some() else None
   
   open MethodInfo
   
  
positive.code:     member this.NotifyPropertyChanged propertyName = 
          propertyChangedEvent.Trigger(this, PropertyChangedEventArgs propertyName)
  
      member this.NotifyPropertyChanged(PropertySelector property: Expr<'Model -> 'Property>) = 
          this.NotifyPropertyChanged property.Name
  
      interface INotifyDataErrorInfo with
          member this.HasErrors = 
  
negative.code:         errors.[propertyName] <- messages
          errorsChanged.Trigger(this, DataErrorsChangedEventArgs propertyName)
  
  and internal PropertyInterceptor() =
      let data = Dictionary()
  
      interface IInterceptor with
          member this.Intercept invocation = 
              match invocation.Method with 
                  | Abstract & PropertySetter propertyName -> 
                      let _, prevValue = data.TryGetValue propertyName
                      data.[propertyName] <- invocation.Arguments.[0]
                      if invocation.Arguments.[0] <> prevValue
                      then 
                          let model: Model = invocation.InvocationTarget |> unbox
                          model.NotifyPropertyChanged propertyName
                          model.SetErrors(propertyName, Array.empty)
  
                  | Abstract & PropertyGetter propertyName ->
                      match data.TryGetValue propertyName with 
                      | true, value -> invocation.ReturnValue <- value 
                      | false, _ -> 
                          let returnType = invocation.Method.ReturnType
                          if returnType.IsValueType then 
                              invocation.ReturnValue <- Activator.CreateInstance returnType
                  | Virtual & PropertySetter propertyName -> 
                      let prevValue = invocation.TargetType.GetProperty(propertyName).GetValue(invocation.InvocationTarget)
                      invocation.Proceed()
                      if invocation.Arguments.[0] <> prevValue
                      then 
                          let model: Model = invocation.InvocationTarget |> unbox
                          model.NotifyPropertyChanged propertyName
                          model.SetErrors(propertyName, Array.empty)
                  | _ -> 
                      invocation.Proceed()
  
  [<RequireQualifiedAccess>]
  module Mvc = 
  