Sick Things in Scala: Implicit Conversions of Functions

Posted by Colin on September 11, 2009 0 comments

I’ve been having a play with seeing just how far Scala can be bent before it is broken.

My latest finding is that you can implicitly convert functions to other types.

For example:

object Sickness {
  class WrappedFunction   
 
  implicit def functionWrapper(f : => Unit) : WrappedFunction = {
    System.out.println("Going to call the function")
    f
 
    // Essential! otherwise the conversion happens infinitely
    new WrappedFunction 
  }
 
  // Have to specify the type so that the function is converted
  def wrapMyFunction : WrappedFunction = { 
    System.out.println("Function called!")
  }
 
  // And to demonstrate...
  def main(args: Array[String]) {
    wrapMyFunction
    wrapMyFunction
 
    /*
     * The above outputs:
     * Going to call the function
     * Function called!
     * Going to call the function
     * Function called!
     */
  }
}

This allows for some pretty funky meta-programming-like gymnastics.

Now to find something useful for this :)