Why cannot pass function name as argument in this case? - scala

Question

This is a question regarding Akka Cookbook chapter 10's recipe on "Enveloping actor". Can someone please explain why we cannot just pass "headers" function as argument but instead have to pass it as "headers _" in creating the envelopingActor?
The original code can be found here: https://github.com/PacktPublishing/Akka-Cookbook/tree/master/Chapter10/src/main/scala/com/packt/chapter10
package com.packt.chapter10
import java.util.UUID
import akka.actor.{Actor, ActorRef, ActorLogging, ActorSystem, Props}
import Envelope._
object Envelope {
type Headers = Map[String, Any]
case class Envelope[T](msg: T, headers: Headers = Map.empty)
}
class EnvelopingActor(nextActor: ActorRef, addHeaders: Any => Headers) extends Actor {
def this(nextActor: ActorRef) =
this(nextActor, _ => Map())
override def receive: Receive = {
case msg => nextActor ! new Envelope(msg, addHeaders(msg))
}
}
class EnvelopeReceiver extends Actor with ActorLogging {
override def receive: Receive = {
case x => log.info(s"Received [$x]")
}
}
object EnvelopingActorApp extends App {
val actorSystem = ActorSystem()
val envelopeReceiver = actorSystem.actorOf(Props[EnvelopeReceiver], "receiver")
val envelopingActor = actorSystem.actorOf(
Props(classOf[EnvelopingActor], envelopeReceiver, headers _))
envelopingActor ! "Hello!"
def headers(msg: Any) = Map(
"t" -> System.currentTimeMillis(),
"cId" -> UUID.randomUUID().toString
)
}

Answer 1

If you try to remove the _ you may see an error like this:
Error:(379, 59) missing argument list for method headers in object EnvelopingActorApp
Unapplied methods are only converted to functions when a function type is expected.
You can make this conversion explicit by writing headers _ or headers(_) instead of headers.
The thing is that Props is a generic container for any set of actor parameters. Particularly it doesn't know beforehand how many parameters there will be. So it uses following signature:
def apply(clazz: Class[_], args: Any*): Props
You may see that args has type of Any*. This * means that number of arguments is variable and each argument is of the most generic type available in Scala - Any, which is not a function type.
As to why Scala compiler does not automatically transforms methods to function types in such case - I think the answer it is type safety. Imagine it did and then at some point you had headers that took no parameters (so headers was effectively a call of the method) and later you modified it to take one parameter. Since Any matches any type, compiler can't notice that this is actually a breaking change (you've changed an in-place-call to passing just a function that might be called later). If the parameter is strongly typed with some function type, the compiler can notice the difference and thus can safely do transformation automatically.