Scalaコンパイラーがデフォルトの引数を持つオーバーロードされたメソッドを許可しないのはなぜですか？

このようなメソッドのオーバーロードがあいまいになる可能性のある有効なケースがあるかもしれませんが、なぜコンパイラはコンパイル時も実行時もあいまいでないコードを許可しないのですか？

例：

// 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 ...

これらの制限を少し緩めることができない理由はありますか？

特に、過負荷のJavaコードをScalaのデフォルト引数に変換することは非常に重要であり、多くのJavaメソッドを1つのScalaメソッドで置き換えた後、スペック/コンパイラーが任意の制限を課していることを知るのはよくありません。

ルーカスリッツ（ここから）を引用します。

その理由は、デフォルトの引数を返す生成されたメソッドに決定論的な命名方式が必要だったからです。あなたが書くなら

def f(a: Int = 1)

コンパイラが生成する

def f$default$1 = 1

同じパラメーター位置にデフォルトを持つ2つのオーバーロードがある場合、異なる命名方式が必要になります。しかし、生成されたバイトコードを複数のコンパイラー実行にわたって安定させておきたいと考えています。

将来のScalaバージョンの解決策は、デフォルトではない引数（メソッドの最初にあり、オーバーロードされたバージョンを明確にするもの）の型名を命名スキーマに組み込むことです。たとえば、次の場合です。

def foo(a: String)(b: Int = 42) = a + b
def foo(a: Int)   (b: Int = 42) = a + b

それは次のようなものになります：

def foo$String$default$2 = 42
def foo$Int$default$2 = 42

SIPの提案を書いてくれる人はいますか？

多重定義解決とデフォルト引数の相互作用について、読みやすく正確な仕様を取得するのは非常に困難です。もちろん、ここに示したような多くの個々のケースでは、何が起こるべきかを言うのは簡単です。しかし、それだけでは十分ではありません。考えられるすべてのコーナーケースを決定する仕様が必要です。多重定義の解像度を指定することはすでに非常に困難です。ミックスにデフォルトの引数を追加すると、さらに難しくなります。そのため、2つを分離することにしました。

私はあなたの質問に答えることはできませんが、これは回避策です：

implicit def left2Either[A,B](a:A):Either[A,B] = Left(a)
implicit def right2Either[A,B](b:B):Either[A,B] = Right(b)

def foo(a: Either[Int, String], b: Int = 42) = a match {
  case Left(i) => i + b
  case Right(s) => s + b
}

1つの引数のみが異なる2つの非常に長い引数リストがある場合、問題を解決する価値があるかもしれません...

私にとってうまくいったのは、オーバーロードメソッドを（Javaスタイルで）再定義することです。

def foo(a: Int, b: Int) = a + b
def foo(a: Int, b: String) = a + b
def foo(a: Int) = a + "42"
def foo(a: String) = a + "42"

これにより、現在のパラメーターに従ってコンパイラーに必要な解像度を保証します。

@Landeiの回答の一般化を次に示します。

あなたが本当に欲しいもの：

def pretty(tree: Tree, showFields: Boolean = false): String = // ...
def pretty(tree: List[Tree], showFields: Boolean = false): String = // ...
def pretty(tree: Option[Tree], showFields: Boolean = false): String = // ...

回避策

def pretty(input: CanPretty, showFields: Boolean = false): String = {
  input match {
    case TreeCanPretty(tree)       => prettyTree(tree, showFields)
    case ListTreeCanPretty(tree)   => prettyList(tree, showFields)
    case OptionTreeCanPretty(tree) => prettyOption(tree, showFields)
  }
}

sealed trait CanPretty
case class TreeCanPretty(tree: Tree) extends CanPretty
case class ListTreeCanPretty(tree: List[Tree]) extends CanPretty
case class OptionTreeCanPretty(tree: Option[Tree]) extends CanPretty

import scala.language.implicitConversions
implicit def treeCanPretty(tree: Tree): CanPretty = TreeCanPretty(tree)
implicit def listTreeCanPretty(tree: List[Tree]): CanPretty = ListTreeCanPretty(tree)
implicit def optionTreeCanPretty(tree: Option[Tree]): CanPretty = OptionTreeCanPretty(tree)

private def prettyTree(tree: Tree, showFields: Boolean): String = "fun ..."
private def prettyList(tree: List[Tree], showFields: Boolean): String = "fun ..."
private def prettyOption(tree: Option[Tree], showFields: Boolean): String = "fun ..."

考えられるシナリオの1つは

  def foo(a: Int)(b: Int = 10)(c: String = "10") = a + b + c
  def foo(a: Int)(b: String = "10")(c: Int = 10) = a + b + c

コンパイラーは、どちらを呼び出すかについて混乱します。他の考えられる危険を防ぐために、コンパイラーは、最大1つのオーバーロードされたメソッドがデフォルトの引数を持つことを許可します。

ちょうど私の推測:-)

私の理解では、コンパイルされたクラスでは、デフォルトの引数値で名前が衝突する可能性があります。いくつかのスレッドで言及されているこれらの行に沿って何かを見たことがあります。

名前付き引数の仕様はここにあります：http : //www.scala-lang.org/sites/default/files/sids/rytz/Mon,%202009-11-09,%2017 : 29/ named- args.pdf

それは述べています：

 Overloading If there are multiple overloaded alternatives of a method, at most one is
 allowed to specify default arguments.

だから、とりあえず当分の間、それはうまくいきません。

あなたはJavaでするのと同じようなことをすることができます、例えば：

def foo(a: String)(b: Int) =  a + (if (b > 0) b else 42)