Besoin de clarification sur les identifiants littéraux Scala (backticks)

En lisant la programmation de Scala 2nd Ed, je suis tombé sur ceci:

identificateur littéral “L’idée est que vous pouvez mettre n’importe quelle chaîne acceptée par le runtime comme identifiant entre backtick”

Je ne suis pas tout à fait sûr pourquoi j’utiliserais ça? Le livre a donné un exemple d’utilisation de l’access à la méthode du rendement statique dans la classe Thread de Java.

Ainsi, à Scala, le rendement est un mot de réserve, si j’utilise le rendement avec

Thread.`yield`() 

il ignorerait le rendement de Scala et me laisserait accéder à la méthode de la classe Thread Java à la place?

Merci d’avance.

Exactement. En utilisant des backticks, vous pouvez plus ou moins donner un nom à un identificateur de champ. En fait, vous pouvez même dire

 val ` ` = 0 

qui définit une variable avec le nom (un caractère d’espacement).

La définition littérale des identificateurs est utile dans deux cas. Le premier cas est celui où il existe déjà un mot réservé du même nom dans Scala et que vous devez utiliser une bibliothèque Java qui ne se soucie pas de cela (et bien sûr, pourquoi).

L’autre cas d’utilisation est livré avec des déclarations de case . La convention est que les noms en minuscules se réfèrent aux variables de correspondance, tandis que les noms en majuscule se réfèrent aux identificateurs de la scope externe. Alors,

 val A = "a" val b = "b" "a" match { case b => println("b") case A => println("A") } 

affiche "b" (si le compilateur était assez stupide pour ne pas échouer en disant que le case A était inaccessible). Si vous souhaitez vous référer à la valeur définie à l’origine val b , vous devez utiliser des backticks comme marqueur.

 "a" match { case `b` => println("b") case A => println("A") } 

Qui imprime "A" .

Add Il existe un cas d’utilisation plus avancé dans cette récente méthode de question avec des crochets angulars (<>) où les backticks étaient nécessaires pour que le compilateur digère le code d’une méthode setter (qui utilise une syntaxe ‘magic’).

Merci @Debilski, cela m’aide à comprendre ce code ci-dessous d’AKKA doc:

 class WatchActor extends Actor { val child = context.actorOf(Props.empty, "child") ... def receive = { ... case Terminated(`child`) ⇒ ... } } 

L’affaire :

 case Terminated(`child`) 

correspond à un message de type Terminé avec le champ ActorRef égal à enfant défini précédemment.

Avec cette déclaration:

 case Terminated(c) 

Nous comparons tous les messages terminés avec toute référence d’ActorRef mappée dans c .