Why is Scala's behavior in case of overloading with by-name parameters different from the case with by-value parameters?

Question

Given this Scala code:

object test {

  def byval(a: Int) = println("Int")
  def byval(a: Long) = println("Long")

  def byname(a: => Int) = println("=> Int")
  def byname(a: => Long) = println("=> Long")

  def main(args: Array[String]) {
      byval(5)
      byname(5)
  }
}

the call byval(5) compiles correctly, but byname fails to compile:

ambiguous reference to overloaded definition

Why? I would expect to observe the same behavior for by-value and by-name parameters with respect to overloading… How can it be fixed?

score 14 · Accepted Answer · answered Dec 01 '10 at 14:31

14

That's because JVM does not support a "by-name" parameter, so Scala has to implement it in another way. => X actually compiles to a Function0[X], which erases to Function0[Object], which makes it impossible for Scala to distinguish two methods that differ only by the expected type of a by-name parameter.

answered Dec 01 '10 at 14:31

Daniel C. Sobral

295,120
86
501
681

Thanks Daniel, this explains the why. Now how can this be worked arouned (if at all possible)? – Jean-Philippe Pellet Dec 01 '10 at 14:36
1

@JPP That's a question that has been asked before. One simple way would be to make the first argument mandatory and not part of the vararg. Other methods involve implicit parameters, but I don't recall the exact tricks. – Daniel C. Sobral Dec 01 '10 at 14:43
@JPP: Don't use overloading in this particular case. – Vasil Remeniuk Dec 01 '10 at 14:43
2

http://scala-programming-language.1934581.n4.nabble.com/Erasure-not-allowing-a-signature-overloading-scenario-td1952173.html – Vasil Remeniuk Dec 01 '10 at 14:45

score 6 · Answer 2 · answered Dec 01 '10 at 15:02

Possible workaround without overloading (in addition to what has been said earlier), if you don't want to use different method names:

def byname[A](a: => A)(implicit manifest:Manifest[A]) = 
manifest.erasure match {
   case erasure if(erasure.isAssignableFrom(classOf[Long])) => println("=> Long")
   case erasure if(erasure.isAssignableFrom(classOf[Int])) => println("=> Int")
}

Why is Scala's behavior in case of overloading with by-name parameters different from the case with by-value parameters?

2 Answers2

Linked