Was bedeuten <: <, <% <und =: = in Scala 2.8 und wo sind sie dokumentiert?

Ich kann in den API-Dokumenten für Predef sehen, dass es sich um Unterklassen eines generischen Funktionstyps (From) => To handelt, aber das ist alles, was darin steht. Ähm, was? Vielleicht gibt es irgendwo Dokumentation, aber Suchmaschinen verarbeiten "Namen" wie "<: <" nicht sehr gut, so dass ich sie nicht finden konnte.

Folgefrage: Wann sollte ich diese funky Symbole / Klassen verwenden und warum?

Diese werden als allgemeine Typeinschränkungen bezeichnet . Sie ermöglichen es Ihnen, innerhalb einer typparametrisierten Klasse oder Eigenschaft eine ihrer Typparameter weiter einzuschränken . Hier ist ein Beispiel:

case class Foo[A](a:A) { // 'A' can be substituted with any type
    // getStringLength can only be used if this is a Foo[String]
    def getStringLength(implicit evidence: A =:= String) = a.length
}

Das implizite Argument evidencewird vom Compiler bereitgestellt, iff Aist String. Sie können als daran denken Beweis , dass Aist String--die Argument selbst ist nicht wichtig, nur zu wissen , dass es existiert. [edit: Nun, technisch gesehen ist es tatsächlich wichtig, weil es eine implizite Konvertierung von Anach darstellt String, was es dir ermöglicht, aufzurufen a.lengthund den Compiler dich nicht anschreien zu lassen]

Jetzt kann ich es so benutzen:

scala> Foo("blah").getStringLength
res6: Int = 4

Aber wenn ich es mit einem Fooanderen als einem String:

scala> Foo(123).getStringLength
<console>:9: error: could not find implicit value for parameter evidence: =:=[Int,String]

Sie können diesen Fehler lesen als "konnte keinen Beweis dafür finden, dass Int == String" ... das ist, wie es sein sollte! getStringLengthlegt weitere Beschränkungen für die Art fest, Aals dies Fooim Allgemeinen erforderlich ist; Sie können nämlich nur getStringLengthauf a aufrufen Foo[String]. Diese Einschränkung wird zur Kompilierungszeit erzwungen, was cool ist!

<:<und <%<arbeiten ähnlich, aber mit geringfügigen Abweichungen:

• A =:= B bedeutet, dass A genau B sein muss
• A <:< Bbedeutet, dass A ein Subtyp von B sein muss (analog zur einfachen Typbeschränkung <:)
• A <%< Bbedeutet, dass A als B angezeigt werden muss , möglicherweise durch implizite Konvertierung (analog zur einfachen Typbeschränkung <%).

Dieses Snippet von @retronym ist eine gute Erklärung dafür, wie so etwas früher erreicht wurde und wie allgemeine Typeinschränkungen es jetzt einfacher machen.

NACHTRAG

Um Ihre Folgefrage zu beantworten, ist das Beispiel, das ich gegeben habe, zugegebenermaßen ziemlich erfunden und offensichtlich nicht nützlich. Stellen Sie sich vor, Sie definieren damit eine List.sumIntsMethode, die eine Liste von Ganzzahlen zusammensetzt. Sie möchten nicht zulassen, dass diese Methode für eine alte Methode aufgerufen wird, sondern Listnur für eine List[Int]. Der ListTypkonstruktor kann jedoch nicht so eingeschränkt werden. Sie möchten weiterhin Listen mit Zeichenfolgen, Foos, Balken und Dingsbums haben können. Wenn Sie also eine allgemeine Typeinschränkung festlegen sumInts, können Sie sicherstellen, dass nur diese Methode eine zusätzliche Einschränkung aufweist, die nur für a verwendet werden kann List[Int]. Im Wesentlichen schreiben Sie Sonderfallcode für bestimmte Arten von Listen.

Keine vollständige Antwort (andere haben dies bereits beantwortet), ich wollte nur Folgendes beachten, was möglicherweise zum besseren Verständnis der Syntax beiträgt: Die Art und Weise, wie Sie diese "Operatoren" normalerweise verwenden, wie zum Beispiel im Beispiel von pelotom:

def getStringLength(implicit evidence: A =:= String)

nutzt die alternative Infix-Syntax von Scala für Typoperatoren .

Also, A =:= Stringist das gleiche wie =:=[A, String](und =:=ist nur eine Klasse oder ein Merkmal mit einem ausgefallenen Namen). Beachten Sie, dass diese Syntax auch mit "regulären" Klassen funktioniert. Sie können beispielsweise Folgendes schreiben:

val a: Tuple2[Int, String] = (1, "one")

so was:

val a: Int Tuple2 String = (1, "one")

Es ähnelt den beiden Syntaxen für Methodenaufrufe, der "normalen" mit .und ()und der Operatorsyntax.

Lesen Sie die anderen Antworten, um zu verstehen, was diese Konstrukte sind. Hier ist, wann Sie sie verwenden sollten. Sie verwenden sie, wenn Sie eine Methode nur für bestimmte Typen einschränken müssen.

Hier ist ein Beispiel. Angenommen, Sie möchten ein homogenes Paar wie folgt definieren:

class Pair[T](val first: T, val second: T)

Jetzt möchten Sie eine Methode smallerwie die folgende hinzufügen :

def smaller = if (first < second) first else second

Das funktioniert nur, wenn Tbestellt wird. Sie können die gesamte Klasse einschränken:

class Pair[T <: Ordered[T]](val first: T, val second: T)

Aber das scheint eine Schande zu sein - es könnte Verwendungszwecke für die Klasse geben, wenn sie Tnicht bestellt wird. Mit einer Typbeschränkung können Sie die smallerMethode weiterhin definieren :

def smaller(implicit ev: T <:< Ordered[T]) = if (first < second) first else second

Es ist in Ordnung zu instanziieren, sagen wir, ein Pair[File], solange Sie nicht nennen smaller darauf.

Im Fall von Optionwollten die Implementierer eine orNullMethode, obwohl dies für nicht sinnvoll ist Option[Int]. Durch die Verwendung einer Typeinschränkung ist alles in Ordnung. Sie können orNullein verwenden Option[String], und Sie können ein bilden Option[Int]und verwenden, solange Sie es nicht aufrufen orNull. Wenn Sie es versuchen Some(42).orNull, erhalten Sie die charmante Nachricht

 error: Cannot prove that Null <:< Int

Es hängt davon ab, wo sie verwendet werden. Wenn sie beim Deklarieren impliziter Parametertypen verwendet werden, handelt es sich meistens um Klassen. In seltenen Fällen können sie auch Objekte sein. Schließlich können sie Operatoren für ManifestObjekte sein. Sie sind scala.Predefin den ersten beiden Fällen im Inneren definiert , jedoch nicht besonders gut dokumentiert.

Sie sollen einen Weg , um die Beziehung zwischen den Klassen zu testen, wie <:und <%zu tun, in Situationen , wenn diese nicht verwendet werden kann.

Die Frage "Wann soll ich sie verwenden?" Lautet, sollten Sie dies nicht tun, es sei denn, Sie wissen, dass Sie es sollten. :-) EDIT : Ok, ok, hier sind einige Beispiele aus der Bibliothek. Ein Either, Sie haben:

/**
  * Joins an <code>Either</code> through <code>Right</code>.
  */
 def joinRight[A1 >: A, B1 >: B, C](implicit ev: B1 <:< Either[A1, C]): Either[A1, C] = this match {
   case Left(a)  => Left(a)
   case Right(b) => b
 }

 /**
  * Joins an <code>Either</code> through <code>Left</code>.
  */
 def joinLeft[A1 >: A, B1 >: B, C](implicit ev: A1 <:< Either[C, B1]): Either[C, B1] = this match {
   case Left(a)  => a
   case Right(b) => Right(b)
 }

Ein Option, Sie haben:

def orNull[A1 >: A](implicit ev: Null <:< A1): A1 = this getOrElse null

Weitere Beispiele finden Sie in den Sammlungen.