Mehrdeutige Referenz auf überladene definition - Einer gegen Zwei Parameter

Angesichts der folgenden Begleiter-Objekt mit überladenen Versionen von apply:

object List {
  def apply[T](): List[T] = new Nil
  def apply[T](x1: T): List[T] = new Cons(x1, new Nil)
  def apply[T](x1: T, x2: T): List[T] = new Cons(x1, new Cons(x2, new Nil))
  def apply[T](elems: T*): List[T] = 
    elems.foldRight(List[T])((elem, l) => new Cons(elem, l))
}

Und die beiden Instanziierungen

List(1) //Error - Ambiguity 
List('a', 'b') //Works fine

scalac beschwert sich über die ersten Instanziierung (mehrdeutigen Verweis auf überladene definition), da sowohl die Einzel-als argument und die varargs-Methode sind ebenso bestimmte.

Suche stackoverflow habe ich gefunden, dass es möglich ist,Kraft das einzige argument der Methode. List[Int](1) wird der compiler verwenden def apply[T](x1: T).

Meine Frage ist, warum hat die zweite Instanziierung match def apply[T](x1: T, x2: T) ohne zusätzliche "hints"? In anderen Worten, warum die beiden argument-Methode mehr bestimmten als die varargs-Methode, wo das einzige argument der Methode nicht?

InformationsquelleAutor Anthony Accioly | 2013-05-30
  1. 7

    Ihre Frage zu beantworten, müssen wir einen Blick auf, was passiert, wenn der Scala-compiler zu erbringen hat, überlastung Auflösung. Dies ist beschrieben in SLS 6.23.3 (für Scala 2.9).

    Nehmen wir eine etwas einfachere version Ihrer Beispiel:

    object Test {
  def apply[T](x1: T) = "one arg"                      //A
  def apply[T](x1: T, x2: T) = "two args"              //B
  def apply[T](elems: T*) = "var-args: " + elems.size  //C
}

    Und Blick auf diese drei Aufrufe:

    Test(1) //fails, ambiguous reference, A and C both match arguments
Test[Int](1) //returns "one arg"
Test(1,2) //returns "two args", not "var-args: 2"

    Lasst uns mit dem ersten beginnen. Zuerst sucht der compiler in der Form jedes argument, das ist ein Typ, der beschreibt, im Grunde, wenn das argument ist ein Wert oder eine Funktion. Hier keine Schwierigkeit, 1 ist eine ganz normale, langweilig Wert und seine Form ist der Typ Nothing.

    Jetzt hat es ein einziges argument 1 Typ Nothing und findet alle alternativen, die für ihn anwendbar sind. Es findet zwei von Ihnen:

    • apply[T](x1: T): man nimmt ein einzelnes argument des unbounded Typ, so kann ein argument vom Typ Nothing,
    • apply[T](elems: T*): es kann angewendet werden, um eine beliebige Anzahl (0 im Lieferumfang enthalten) der Argumente des gleichen unbounded Typ, so kann ein einzelnes element vom Typ Nothing.

    Gab es nur ein, er würde dort anhalten und wählen, dass man.

    Der zweite Schritt ist gleich wie oben, außer dieser Zeit, es Typen, die jedes argument mit einer unbestimmten erwarteten Typ. Hier im Grunde sieht es bei den beiden alternativen Links und findet heraus, ob Sie anwendbar sind auf das argument 1 Typ A <: Int. Kein Glück, Sie beide sind.
    Wenn Sie waren zwei ändern apply[T](x1: T) zu apply(x1: String) und lassen Sie die anderen allein, hier gibt es nur eine anwendbare alternative Links, und es würde gelingen und stoppen.

    Dann der compiler berechnet die relative weight jeder Links-alternative über einander. Die SLS-Staaten, die

    Den relative Gewicht einer alternative A gegenüber einer alternative B ist eine Zahl von 0 bis 2,
    definiert als die Summe der

    • 1 wenn A ist so spezifisch wie B , sonst 0, und
    • 1, wenn A in einer Klasse definiert oder-Objekt, das abgeleitet ist von der Klasse oder Objekt
      Definition von B , sonst 0.

    Zu diesem Zeitpunkt muss es eine alternative, die eine höhere Punktzahl als alle anderen, oder gibt es eine Mehrdeutigkeit Fehler. Wir ignorieren das "definiert" Teil, definiert sind Sie in der gleichen Stelle.

    • A ist so spezifisch wie C da kann man immer anrufen C mit dem einzigen argument von A,
    • C ist so spezifisch wie A weil der Typ-Inferenz: Sie können immer Aufruf A mit dem argument der C seit A kann alles (der parameter Typ abgeleitet werden kann, auf das, was wir wollen). C's-Parameter ist als eine Seq[A] so T abgeleitet, wie Seq[A] im A und es kann sich so nennen. So C ist so spezifisch wie A.

    Dies kann gesehen werden, wenn Sie ändern A zu apply[T <: Int](x: T): es geht den ganzen Weg zu suchen, für die bestimmte, aber dieses mal Typ-Inferenz, kann nicht einen Weg finden, um A geltenden C's argument (ein Seq) denn es ist nicht ein Subtyp von Int, so A spezifischer ist. Natürlich, das gleiche passiert, wenn Sie ändern A zu apply(x: Int), Typ-Inferenz, kann nicht einmal etwas tun.

    Dies erklärt auch, warum Test[Int](1) gelingt, ruft das eine argument-version. Die letzten beiden alternativen sind identisch, aber A's type-parameter gebunden wurde, um Int - und Typ-Inferenz, kann es nicht ändern, um zu passen C's argument mehr.

    Schließlich, die Anwendung der gleichen Logik gibt, warum Test(1,2) gut funktioniert:

    • B ist so spezifisch wie C: Sie können immer Aufruf C mit B's Argumente,
    • aber C ist nicht so spezifisch wie B: Nein Menge von Typ-Inferenz wird verwalten zu passen, einen einzelnen Seq in eine Methode, die zwei Parameter.

    So apply[T](x1: T, x2: T) spezifischer ist und keine Fehler vorhanden sind.

    Grundsätzlich für eine var-arg und eine normale Methode, um zu produzieren, eine Zweideutigkeit, Sie werden Sie brauchen, um die gleiche Anzahl von Argumenten und einen trick, mit dem Typ-Inferenz, die auf (mindestens) das Letzte argument:

    def apply[T](x1: T)
def apply[T](x: T*)

    Oder

    def apply[T](x1: Int, x2:T)
def apply[T](x1: Int, x: T*)

    Und so weiter...

    Bearbeiten: ich war mir nicht sicher zuerst, ob der parameter wiederholt gesehen wurde, als Seq[A] oder eine TupleX[...] bei der Suche nach der Besonderheit. Es ist definitiv nicht ein Tupel, und auto-tupling hat nichts zu tun mit dieser Sache.

    • "die Kreuzung zu überladen, Polymorphismus und Typ-Inferenz": lassen Sie sich nicht diese paulpism die Irre führen. Er meinte nur, dass wenn der compiler verhielt Sie sich wie Sie nicht haben, um nichts ableiten, weil es wie so offensichtlich aus dem func-Anwendung, dann würden Sie nicht haben, um die Versorgung der Typ arg.
    • oh, wie ich sehe. Ich bin traurig, ich dachte er meinte eher allgemein, dass, wenn diese 3 orthogonale Konzepte überschneiden sich, seltsame Dinge geschehen.
    InformationsquelleAutor gourlaysama
  2. 3

    Fester stelligkeit Methode wird immer mehr spezifisch als die var-Dimension.

    f(P1, P2) gilt nicht für (a, b, c, ...) ist, wie man sich denken kann f(P*).

    Umgekehrt, obwohl f(P*) nimmt die Form f(p1,..,pn) für die Zwecke der Anwendbarkeit auf die N Argumente. Also es gilt immer und ist nicht so spezifisch wie die Feste stelligkeit Methode.

    So, dass ist der übliche Grund, Ihre f(a,b) ist spezifischer als f(P*).

    Für die eine-arg-Fall, es hängt davon ab, was Sie abholen für die Typ-param.

    f[A](a: A) gilt für (a, b, ...) von tupling und wobei Ein als ein Tupel.

    Sagen = Int, dann ist das offensichtlich Ein nicht zu genommen werden, als ein Tupel.

    Probe Verwirrung über die var-Dimension und wie wirkt Besonderheit:

    https://issues.scala-lang.org/browse/SI-4728

    object Foo {
  def apply[T](): Int = 1
  def apply[T](x1: T): Int = 2
  def apply[T](x1: T, x2: T): Int = 3
  def apply[T](elems: T*): Int = 4

  //two or more
  def canonically[T](x1: T, x2: T, rest: T*): List[T] = ???
}

object Test extends App {
  Console println Foo(7)
  Console println Foo[Int](7)
  Console println Foo(7,8)
  Console println Foo[Pair[Int,Int]](7,8)
}

    Möchten Sie vielleicht Stelle diese Frage auf stackoverload.com die Seite, wo die überlastung Spezialisten sammeln. Ihr browser umgeleitet werden kann, um overloading-is-evil.com.

    • Ich verstehe nicht, wie man diese Antworten zu den OPs Frage. Bitte erläutern Sie.
    • som, danke für die Erklärung. Nur um der Klarheit Willen.. In Foo(x1: T), T könnte ein Tuple, Tupel und varargs sind gleichermaßen spezifisch, das ist, warum ich brauchen, um anzudeuten, der compiler, dass T ist nicht ein Tupel Recht?
    • Ja, "ist so spezifisch wie" ist ein test, ob eine Methode gilt für den (hypothetischen) Argumente der anderen. Wenn der Parameter-Typ T oder einer, dann kann man Tupel Ihren Weg in die Herstellung weder noch "spezifischer" als die anderen. Die kanonische form für 2 oder mehr nicht das problem habe, aber es ist schwieriger zu verwenden. Mein quickie Idee mal war die Schreibweise f(two_plus: A{2,}) also innerhalb der Funktion, die Sie nur mit einer Seq.
    • Thx @gzm0, war ich Rauschen aus der Tür zum Kindergarten auf der ersten gehen.
    InformationsquelleAutor som-snytt
Schreibe einen Kommentar