title: Why does the Scala compiler disallow overloaded methods with default arguments?
body: <p>While there might be valid cases where such method overloadings could become ambiguous, why does the compiler disallow code which is neither ambiguous at compile time nor at run time?</p>
  
  <p>Example:</p>
  
  <pre><code>// This fails:
  def foo(a: String)(b: Int = 42) = a + b
  def foo(a: Int)   (b: Int = 42) = a + b
  
  // This fails, too. Even if there is no position in the argument list,
  // where the types are the same.
  def foo(a: Int)   (b: Int = 42) = a + b
  def foo(a: String)(b: String = "Foo") = a + b
  
  // This is OK:
  def foo(a: String)(b: Int) = a + b
  def foo(a: Int)   (b: Int = 42) = a + b    
  
  // Even this is OK.
  def foo(a: Int)(b: Int) = a + b
  def foo(a: Int)(b: String = "Foo") = a + b
  
  val bar = foo(42)_ // This complains obviously ...
  </code></pre>
  
  <p>Are there any reasons why these restrictions can't be loosened a bit?</p>
  
  <p>Especially when converting heavily overloaded Java code to Scala default arguments are a very important and it isn't nice to find out after replacing plenty of Java methods by one Scala methods that the spec/compiler imposes arbitrary restrictions.</p>