Que signifient <: <, <% <et =: = dans Scala 2.8, et où sont-ils documentés?

Je peux voir dans la documentation de l'API pour Predef qu'il s'agit de sous-classes d'un type de fonction générique (From) => To, mais c'est tout ce qu'il dit. Euh, quoi? Peut-être qu'il y a de la documentation quelque part, mais les moteurs de recherche ne gèrent pas très bien les "noms" comme "<: <", donc je n'ai pas pu le trouver.

Question de suivi: quand dois-je utiliser ces symboles / classes géniaux, et pourquoi?

Celles-ci sont appelées contraintes de type généralisées . Ils vous permettent, à partir d'une classe ou d'un trait paramétré par type, de contraindre davantage l' un de ses paramètres de type. Voici un exemple:

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
}

L'argument implicite evidenceest fourni par le compilateur, iff Ais String. Vous pouvez penser comme une preuve que Aest String--Le argument lui - même n'a pas d' importance, ne sachant qu'il existe. [edit: eh bien, techniquement, c'est réellement important parce qu'il représente une conversion implicite de Aà String, ce qui vous permet d'appeler a.lengthet de ne pas crier sur le compilateur]

Maintenant, je peux l'utiliser comme ça:

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

Mais si j'ai essayé de l'utiliser avec un Foocontenant autre chose qu'un String:

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

Vous pouvez lire cette erreur comme "n'a pas pu trouver la preuve que Int == String" ... c'est comme ça! getStringLengthimpose des restrictions supplémentaires sur le type de Ace qui est Foogénéralement requis; à savoir, vous ne pouvez invoquer que getStringLengthsur un Foo[String]. Cette contrainte est appliquée au moment de la compilation, ce qui est cool!

<:<et <%<fonctionnent de la même manière, mais avec de légères variations:

• A =:= B signifie que A doit être exactement B
• A <:< Bsignifie que A doit être un sous-type de B (analogue à la contrainte de type simple<: )
• A <%< Bsignifie que A doit être visible comme B, éventuellement via une conversion implicite (analogue à la contrainte de type simple <%)

Cet extrait de @retronym est une bonne explication de la façon dont ce genre de choses était accompli et comment les contraintes de type généralisées facilitent maintenant.

ADDENDA

Pour répondre à votre question de suivi, il est vrai que l'exemple que j'ai donné est assez artificiel et n'est évidemment pas utile. Mais imaginez l'utiliser pour définir quelque chose comme une List.sumIntsméthode, qui additionne une liste d'entiers. Vous ne voulez pas autoriser cette méthode à être invoquée sur n'importe quel ancien List, juste un List[Int]. Cependant, le Listconstructeur de type ne peut pas être aussi contraint; vous voulez toujours pouvoir avoir des listes de chaînes, foos, barres et autres joyeusetés. Ainsi, en plaçant une contrainte de type généralisé sur sumInts, vous pouvez vous assurer que cette méthode a une contrainte supplémentaire qu'elle ne peut être utilisée que sur un List[Int]. Essentiellement, vous écrivez du code spécial pour certains types de listes.

Pas une réponse complète (d'autres ont déjà répondu à cela), je voulais juste noter ce qui suit, ce qui peut peut-être aider à mieux comprendre la syntaxe: La façon dont vous utilisez normalement ces "opérateurs", comme par exemple dans l'exemple de pelotom:

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

utilise la syntaxe alternative de Scala pour les opérateurs de type .

Donc, A =:= Stringc'est la même chose que =:=[A, String](et =:=c'est juste une classe ou un trait avec un nom fantaisiste). Notez que cette syntaxe fonctionne également avec les classes "normales", par exemple vous pouvez écrire:

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

comme ça:

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

Elle est similaire aux deux syntaxes pour les appels de méthode, la "normale" avec .et ()et la syntaxe d'opérateur.

Lisez les autres réponses pour comprendre quelles sont ces constructions. Voici quand vous devez les utiliser. Vous les utilisez lorsque vous devez contraindre une méthode pour des types spécifiques uniquement.

Voici un exemple. Supposons que vous souhaitiez définir une paire homogène, comme ceci:

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

Maintenant, vous voulez ajouter une méthode smaller, comme ceci:

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

Cela ne fonctionne que si Test commandé. Vous pouvez restreindre la classe entière:

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

Mais cela semble dommage - il pourrait y avoir des utilisations pour la classe quand elle Tn'est pas commandée. Avec une contrainte de type, vous pouvez toujours définir la smallerméthode:

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

C'est correct d'instancier, disons, a Pair[File], tant que vous ne faites pas appel smaller à cela.

Dans le cas de Option, les implémenteurs voulaient une orNullméthode, même si cela n'a pas de sens Option[Int]. En utilisant une contrainte de type, tout va bien. Vous pouvez utiliser orNullsur un Option[String], et vous pouvez former un Option[Int]et l'utiliser, tant que vous ne faites pas appel orNullà lui. Si vous essayez Some(42).orNull, vous obtenez le charmant message

 error: Cannot prove that Null <:< Int

Cela dépend de l'endroit où ils sont utilisés. Le plus souvent, lorsqu'ils sont utilisés lors de la déclaration de types de paramètres implicites, ce sont des classes. Ils peuvent aussi être des objets dans de rares cas. Enfin, ils peuvent être des opérateurs sur des Manifestobjets. Ils sont définis à l'intérieur scala.Predefdans les deux premiers cas, mais pas particulièrement bien documentés.

Ils sont destinés à fournir un moyen de tester la relation entre les classes, tout comme <:et le <%font, dans des situations où ces dernières ne peuvent pas être utilisées.

Quant à la question "quand dois-je les utiliser?", La réponse est que vous ne devriez pas, à moins que vous sachiez que vous devriez. :-) EDIT : Ok, ok, voici quelques exemples de la bibliothèque. Sur Either, vous avez:

/**
  * 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)
 }

Sur Option, vous avez:

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

Vous trouverez d'autres exemples sur les collections.