anchor.diff:      member this.NotifyPropertyChanged propertyName = 
           propertyChangedEvent.Trigger(this, PropertyChangedEventArgs propertyName)
   
  -    member this.NotifyPropertyChanged(PropertySelector property: Expr<'Model -> 'Property>) = 
  -        this.NotifyPropertyChanged property.Name
  +    member this.NotifyPropertyChanged(propertySelector: Expr)= 
  +        match propertySelector with 
  +        | Patterns.PropertyGet(_, property, _) -> this.NotifyPropertyChanged property.Name
  +        | _ -> invalidOp "Expecting property getter expression"
   
       interface INotifyDataErrorInfo with
           member this.HasErrors = 
  
positive.code:         | _ -> None
  
      let (|Abstract|_|) (m : MethodInfo) = if m.IsAbstract then Some() else None
  
  open MethodInfo
  
  
negative.code:     let errorsChanged = Event<_,_>()
  
      static let proxyFactory = ProxyGenerator()
      static let proxyOptions = ProxyGenerationOptions {
          new IProxyGenerationHook with
              member __.ShouldInterceptMethod(type', method') = 
                  match method' with 
                  | Virtual & PropertySetter propertyName when type'.GetProperty(propertyName).GetGetMethod() <> null -> true
                  | Virtual & PropertyGetter propertyName when type'.GetProperty(propertyName).GetSetMethod() <> null -> true 
                  | _ -> false 
              member __.NonProxyableMemberNotification(_, _) = ()          
              member __.MethodsInspected() = ()          
      }
  
      static member Create<'T when 'T :> Model and 'T : not struct>([<ParamArray>] constructorArguments)  = 
          let interceptors : IInterceptor[] = [| PropertyInterceptor() |]
          proxyFactory.CreateClassProxy(typeof<'T>, proxyOptions, constructorArguments, interceptors) |> unbox<'T>    
  
      interface INotifyPropertyChanged with
  