anchor.diff:                          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()
   
  
positive.code:         | _ -> 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
  
  
negative.code:         new IProxyGenerationHook with
              member __.ShouldInterceptMethod(type', method') = 
                  match method' with 
                  | Abstract & PropertySetter _ | Abstract & PropertyGetter _ -> true 
                  | _ -> false 
              member __.NonProxyableMemberNotification(_, _) = ()          
              member __.MethodsInspected() = ()          
      }
  
      static member Create<'T when 'T :> Model and 'T : not struct>([<ParamArray>] constructorArguments)  = 
          let interceptors : IInterceptor[] = [| AbstractProperties() |]
          proxyFactory.CreateClassProxy(typeof<'T>, proxyOptions, constructorArguments, interceptors) |> unbox<'T>    
  
      interface INotifyPropertyChanged with
  