Reactive.scala

object Reactive {

  type Signaled[T] = implicit Signal[_] => T

  class Signal[T](expr: Signaled[T]) {
    private var myExpr: () => T = _
    private var myValue: T = _
    private var observers: Set[Signal[_]] = Set()
    update(expr)

    protected def update(expr: Signaled[T]): Unit = {
      myExpr = () => expr(this)
      computeValue()
    }

    protected def computeValue(): Unit = {
      val newValue = myExpr()
      if (myValue != newValue) {
        myValue = newValue
        val obs = observers
        observers = Set()
        obs.foreach(_.computeValue())
      }
    }

    def apply()(implicit caller: Signal[_] = NoSignal): T = {
      observers += caller
      assert(!caller.observers.contains(this), "cyclic signal definition")
      myValue
    }
  }

  object NoSignal extends Signal(???) {
    override def computeValue() = ()
  }

  object Signal {
    def apply[T](expr: Signaled[T]): Signal[T] = new Signal(expr)
  }

  class Var[T](expr: Signaled[T]) extends Signal(expr) {
    override def update(expr: Signaled[T]): Unit = super.update(expr)
  }

  object Var {
    def apply[T](expr: Signaled[T]): Var[T] = new Var(expr)
  }
}