Necesita aclaración sobre los identificadores literales de Scala (palos de fondo)

Leyendo la Progtwigción en Scala 2nd Ed y me encontré con esto:

identificador literal “La idea es que puedes poner cualquier cadena que sea aceptada por el tiempo de ejecución como un identificador entre backtick”

No estoy del todo seguro de por qué usaría esto? El libro dio un caso de uso para acceder al método de rendimiento estático en la clase Thread de Java.

Entonces, como en Scala, yield es una palabra de reserva, si utilizo yield con backticks,

Thread.`yield`() 

ignoraría el rendimiento de la Scala y, en cambio, ¿me permitiría acceder al rendimiento del método de la clase Thread de Java?

Gracias de antemano.

Exactamente. Usando los trazos atrás, puede dar más o menos cualquier nombre a un identificador de campo. De hecho, incluso puedes decir

 val ` ` = 0 

que define una variable con nombre (un personaje de espacios en blanco).

La definición literal de identificadores es útil en dos casos. El primer caso es cuando ya hay una palabra reservada del mismo nombre en Scala y necesita usar una biblioteca Java que no se preocupa por eso (y por supuesto, ¿por qué debería hacerlo?).

El otro caso de uso viene con declaraciones de case . La convención es que los nombres minúsculos se refieren a las variables de coincidencia, mientras que los nombres de mayúsculas se refieren a los identificadores del scope externo. Asi que,

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

imprime "b" (si el comstackdor fue lo suficientemente tonto como para no fallar al decir que el case A estaba disponible). Si desea consultar el valor de referencia definido originalmente, debe usar los marcadores de retroceso como marcador.

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

Que imprime "A" .

Agregar Hay un caso de uso más avanzado en este método de pregunta reciente con corchetes angulares (<>) donde los backticks eran necesarios para que el compilador dijera el código de un método setter (que en sí mismo usa alguna sintaxis ‘mágica’).

Gracias @Debilski, me ayuda a entender este código a continuación del documento de AKKA:

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

El caso :

 case Terminated(`child`) 

coincide con un mensaje de tipo Terminado con el campo ActorRef igual a secundario que se definió anteriormente.

Con esta statement:

 case Terminated(c) 

Emparejamos todos los mensajes finalizados con cualquier referencia de ActorRef mapeada en c .