I need a smart mechanism for component composition which allows mixed in traits to initialize *after* the composed component. The following throws a `NullPointerException`:

```
class Component {
  def addListener(pf: PartialFunction[Any, Unit]) {}
}

trait DynamicComponent {
  protected def component: Component

  component.addListener {
    case x =>
  }
}

class Foo extends DynamicComponent {
  protected val component = new Component
}

new Foo  // -> NullPointerException

```

The following things are *not options* for me:

* Using `protected lazy val component`; that would produce an **avalange** of dozens of vals needing to become lazy, something **I do not want**.
* Putting `addListener` in a method, e.g. `initDynamic()`; because I will be mixing in many traits, and I don't want to remember to call half a dozen `initFoo()` methods.
* Using `DelayedInit`. This doesn't work with traits, at least according to the scaladocs.

I could live with a single `init()` call, but only under the following conditions:

* all mixed in traits can easily declare to be invoked in this one single call
* it is a compile error to forget the `init()` statement.