Warum verbietet der Scala-Compiler überladene Methoden mit Standardargumenten?

Während es gültige Fälle geben kann, in denen solche Methodenüberladungen mehrdeutig werden können, warum verbietet der Compiler Code, der weder zur Kompilierungszeit noch zur Laufzeit mehrdeutig ist?

Beispiel:

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

Gibt es Gründe, warum diese Einschränkungen nicht ein wenig gelockert werden können?

Insbesondere beim Konvertieren von stark überlastetem Java-Code in Scala sind Standardargumente sehr wichtig, und es ist nicht schön herauszufinden, dass der Spec / Compiler nach dem Ersetzen vieler Java-Methoden durch eine Scala-Methode willkürliche Einschränkungen auferlegt.

Ich möchte Lukas Rytz (von hier ) zitieren :

Der Grund ist, dass wir ein deterministisches Namensschema für die generierten Methoden wollten, die Standardargumente zurückgeben. Wenn du schreibst

def f(a: Int = 1)

Der Compiler generiert

def f$default$1 = 1

Wenn Sie zwei Überladungen mit Standardwerten an derselben Parameterposition haben, benötigen wir ein anderes Namensschema. Wir möchten den generierten Bytecode jedoch über mehrere Compilerläufe hinweg stabil halten.

Eine Lösung für die zukünftige Scala Version könnte einzuarbeiten Typnamen der Nicht-Standard - Argumente (die am Anfang eines Verfahrens, welche Versionen überlastet disambiguate) in das Namensschema, zB in diesem Fall:

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

es wäre so etwas wie:

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

Jemand, der bereit ist , einen SIP-Vorschlag zu schreiben ?

Es wäre sehr schwierig, eine lesbare und präzise Spezifikation für die Wechselwirkungen der Überladungsauflösung mit Standardargumenten zu erhalten. Natürlich ist es für viele Einzelfälle, wie den hier vorgestellten, leicht zu sagen, was passieren soll. Das reicht aber nicht. Wir brauchen eine Spezifikation, die alle möglichen Eckfälle entscheidet. Die Überladungsauflösung ist bereits sehr schwer anzugeben. Das Hinzufügen von Standardargumenten in der Mischung würde es noch schwieriger machen. Deshalb haben wir uns entschieden, die beiden zu trennen.

Ich kann Ihre Frage nicht beantworten, aber hier ist eine Problemumgehung:

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
}

Wenn Sie zwei sehr lange Arg-Listen haben, die sich nur in einem Arg unterscheiden, ist es möglicherweise die Mühe wert ...

Was für mich funktioniert hat, ist die Neudefinition (Java-Stil) der Überladungsmethoden.

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"

Dies stellt dem Compiler sicher, welche Auflösung Sie gemäß den aktuellen Parametern wünschen.

Hier ist eine Verallgemeinerung der @ Landi-Antwort:

Was Sie wirklich wollen:

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

Workarround

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

Eines der möglichen Szenarien ist

  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

Der Compiler wird verwirrt sein, welchen er aufrufen soll. Um andere mögliche Gefahren zu vermeiden, würde der Compiler höchstens eine überladene Methode mit Standardargumenten zulassen.

Nur meine Vermutung :-)

Nach meinem Verständnis kann es in den kompilierten Klassen mit Standardargumentwerten zu Namenskollisionen kommen. Ich habe etwas in dieser Richtung gesehen, das in mehreren Threads erwähnt wurde.

Die angegebene Argumentspezifikation finden Sie hier: http://www.scala-lang.org/sites/default/files/sids/rytz/Mon,%202009-11-09,%2017:29/named-args.pdf

Es sagt aus:

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

Auf jeden Fall wird es vorerst nicht funktionieren.

Sie könnten so etwas wie in Java tun, z. B.:

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