идиоматическое свойство изменило уведомление в scala?

Я пытаюсь найти более чистую альтернативу (который идиоматичен Scala) к виду вещи, которую Вы видите с привязкой данных в WPF/silverlight, связывающем с данными - то есть, реализовывая INotifyPropertyChanged. Во-первых, некоторый фон:

В.Net WPF или приложениях Silverlight, у Вас есть понятие двухсторонней привязки данных (то есть, связывая значение некоторого элемента UI к свойству .NET DataContext таким способом, который изменяет на влияние элемента UI свойство, и наоборот. Один способ включить это состоит в том, чтобы реализовать интерфейс INotifyPropertyChanged в Вашем DataContext. К сожалению, это представляет много шаблонного кода для любого свойства, которое Вы добавляете к типу "ModelView". Вот то, как это могло бы посмотреть в Scala:

trait IDrawable extends INotifyPropertyChanged
{    
      protected var drawOrder : Int = 0
      def DrawOrder : Int = drawOrder
      def DrawOrder_=(value : Int) {
            if(drawOrder != value) {
                  drawOrder = value
                  OnPropertyChanged("DrawOrder")
            }
      }

      protected var visible : Boolean = true
      def Visible : Boolean = visible
      def Visible_=(value: Boolean) = {
            if(visible != value) {
                  visible = value
                  OnPropertyChanged("Visible")
            }
      }
      def Mutate() : Unit = {
          if(Visible) {
              DrawOrder += 1 // Should trigger the PropertyChanged "Event" of INotifyPropertyChanged trait
          }
      }
}

Для экономии места давайте предположим, что тип INotifyPropertyChanged является чертой, которая управляет списком обратных вызовов типа (AnyRef, Строка) => Единица, и что OnPropertyChanged является методом, который вызывает все те обратные вызовы, передавая "это" как AnyRef и переданный - в Строке). Это просто было бы событием в C#.

Можно сразу видеть проблему: это - тонна шаблонного кода всего для двух свойств. Я всегда хотел записать что-то вроде этого вместо этого:

trait IDrawable
{
      val Visible = new ObservableProperty[Boolean]('Visible, true)
      val DrawOrder = new ObservableProperty[Int]('DrawOrder, 0)
      def Mutate() : Unit = {
          if(Visible) {
              DrawOrder += 1 // Should trigger the PropertyChanged "Event" of ObservableProperty class
          }
      }
}

Я знаю, что могу легко записать это как это, если ObservableProperty[T] имеет Значение/Значение _ = методы (это - метод, который я использую теперь):

trait IDrawable {
      // on a side note, is there some way to get a Symbol representing the Visible field
      // on the following line, instead of hard-coding it in the ObservableProperty 
      // constructor?
      val Visible = new ObservableProperty[Boolean]('Visible, true)
      val DrawOrder = new ObservableProperty[Int]('DrawOrder, 0)
      def Mutate() : Unit = {
          if(Visible.Value) {
              DrawOrder.Value += 1 
          }
      }
}

// given this implementation of ObservableProperty[T] in my library
// note: IEvent, Event, and EventArgs are classes in my library for
// handling lists of callbacks - they work similarly to events in C#
class PropertyChangedEventArgs(val PropertyName: Symbol) extends EventArgs("")
class ObservableProperty[T](val PropertyName: Symbol, private var value: T) {
    protected val propertyChanged = new Event[PropertyChangedEventArgs]
    def PropertyChanged: IEvent[PropertyChangedEventArgs] = propertyChanged
    def Value = value;
    def Value_=(value: T) {
        if(this.value != value) {
            this.value = value
            propertyChanged(this, new PropertyChangedEventArgs(PropertyName))
        }
    }
}

Но есть ли какой-либо способ реализовать первую версию с помощью implicits или некоторую другую функцию/идиому Scala для создания функции экземпляров ObservableProperty, как будто они были регулярными "свойствами" в scala, не будучи должен назвать методы Значения? Единственная другая вещь, о которой я могу думать, является чем-то вроде этого, которое является более подробным, чем любая из вышеупомянутых двух версий, но является все еще менее подробным, чем оригинал:

trait IDrawable {     
  private val visible = new ObservableProperty[Boolean]('Visible, false)
  def Visible = visible.Value
  def Visible_=(value: Boolean): Unit = { visible.Value = value }

  private val drawOrder = new ObservableProperty[Int]('DrawOrder, 0)
  def DrawOrder = drawOrder.Value
  def DrawOrder_=(value: Int): Unit = { drawOrder.Value = value }

  def Mutate() : Unit = {
    if(Visible) {
      DrawOrder += 1 
    }
  }
}