Question

I have a class that I’m trying to make extend DelayedInit:

class Foo extends DelayedInit {
  // expensive initialisation code
}

However when I try to run sbt compile I get the error:

Foo needs to be abstract, since method delayedInit in trait DelayedInit of type (x: => Unit)Unit is not defined

My understanding is that by extending the DelayedInit trait any initialisation code should automatically be wrapped in a closure and run in the delayedInit method after initialisation is complete. However I’ve had a stab at googling and can’t seem to find an example of usage. What am I missing?

Answer 1

How DelayedInit Works and its Sample Usage

DelayedInit trait provides the ability to control at which point initialisation code within a class or an object (but not a trait) is run.

Any initialisation code within classes or objects (but not traits) that are inherited from DelayedInit is passed by compiler during the initialisation to the delayedInit method and then it’s up to you when you want to run it.

delayedInit method is called automatically as part of the initialisation and running the code that is passed as a parameter straight away within the method is still running the code during the initialisation.

Let’s start with a basic scenario:

object Main extends DelayedInit  {

   println ("  initialisation of Main object")
   override def delayedInit (body: => Unit) {
     println("delayedInit")
     body
   }

   def main (args: Array[String]) {
     println("main method") 
   }
}

Will print:

delayedInit
  initialisation of Main object
main method

In fact, delayedInit method will be called once for every class that inherits the trait within the class hierarchy. A slightly more complicated scenario:

abstract class MyApplication extends DelayedInit {
   println ("  initialisation of MyApplication class")
}

object Main extends MyApplication  {

   println ("  initialisation of Main object")
   override def delayedInit (body: => Unit) {
     println("delayedInit")
     body
   }

   def main (args: Array[String]) {
     println("main method") 
   }
}

Will print:

delayedInit
  initialisation of MyApplication class
delayedInit
  initialisation of Main object
main method

Since main method is the first method to run once the initialisation is over, what we really want to do is to save all the initialisation code passed to delayedInit and run it later, probably from within main, since there is potentially more than one bit of code we could conveniently store it in a ListBuffer (we need to keep appending to preserve the natural execution order). The code inside ‘Main` object could look something like this:

private val init = new scala.collection.mutable.ListBuffer[()=>Unit]
override def delayedInit (body: => Unit) {
  println("delayedInit")
  init += (()=>body) // will result in NullPointerException
}


def main (args: Array[String]) {
  println("main method") 
  for (code <- init) code ()
}

However, there is a catch 22: because initialisation of init field is delayed along with every other initialisation statement there isn’t any ListBuffer[()=>Unit] object to preserve the initialisation code for later use!

But, remember?

Any initialisation code within classes or objects (but not traits)
that are inherited from DelayedInit is passed by compiler during the
initialisation to the delayedInit method…

Let’s re-shuffle things a bit, move functionality that memorises the code for later use into StoredInit trait that inherits directly from DelayedInit:

trait StoredInit extends DelayedInit {
   println ("initialisation of StoredInit trait")
   private val init = new scala.collection.mutable.ListBuffer[()=>Unit]
   override def delayedInit (body: => Unit) {
     println("delayedInit")
     init += (()=>body)
   }   
   def initialise () {
     for (code <- init) code ()     
   }
}

// extend StoredInit instead of DelayedInit
abstract class MyApplication extends StoredInit {
   println ("  initialisation of MyApplication class")
}

object Main extends MyApplication  {

   println ("  initialisation of Main object")

   def main (args: Array[String]) {
     println("main method") 
     initialise() // finally perform the delayed initialisation
   }
}

Will print:

initialisation of StoredInit trait
delayedInit
delayedInit
main method
  initialisation of MyApplication class
  initialisation of Main object

Finally, why doesn’t DelayedInit trait include a default implementation of delayedInit method?

To keep the compiler hook de-coupled from the actual implementation of delayed initialisation behaviour. The desired behaviour will be different for console application and server-side component that has to work within a specific container.

trait App, however, inherits from DelayedInit and provides default implementation for Scala applications.