Hai bisogno di chiarimenti sugli identificatori letterali di Scala (backtick)

Leggendo la programmazione in Scala 2 ° Ed e mi sono imbattuto in questo:

identificatore letterale “L’idea è che puoi inserire qualsiasi stringa accettata dal runtime come identificatore tra apice”

Non sono del tutto sicuro del perché lo userei? Il libro ha fornito un caso d’uso per accedere al metodo di rendimento statico nella class Thread di Java.

Quindi, dato che in Scala, la resa è una parola di riserva, se uso la resa con i backtick,

Thread.`yield`() 

ignorerebbe il rendimento di Scala e mi consentirà invece di accedere al rendimento del metodo della class Thread di Java?

Grazie in anticipo.

Esattamente. Usando i backtick, puoi dare più o meno un nome a un identificatore di campo. In effetti, puoi anche dire

 val ` ` = 0 

che definisce una variabile con nome (un carattere di spazio bianco).

La definizione letterale di identificatori è utile in due casi. Il primo caso è, quando c’è già una parola riservata con lo stesso nome in Scala e devi usare una libreria Java a cui non importa (e, naturalmente, perché dovrebbe).

L’altro caso d’uso viene fornito con le dichiarazioni del case . La convenzione è che i nomi in minuscolo fanno riferimento alle variabili di corrispondenza, mentre i nomi in maiuscolo si riferiscono agli identificatori dall’ambito esterno. Così,

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

stampa "b" (se il compilatore fosse abbastanza stupido da non fallire nel dire che il case A era irraggiungibile). Se si desidera fare riferimento alla val b originariamente definita, è necessario utilizzare i backtick come marker.

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

Che stampa "A" .

Aggiungi C’è un caso d’uso più avanzato in questo recente metodo di domanda con parentesi angolari (<>) in cui i backtick erano necessari per ottenere il compilatore per digerire il codice per un metodo setter (che di per sé utilizza una sintassi ‘magica’).

Grazie @Debilski, mi aiuta a capire questo codice qui sotto da AKKA doc:

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

Il caso :

 case Terminated(`child`) 

corrisponde a un messaggio di tipo Terminato con il campo ActorRef uguale al figlio definito in precedenza.

Con questa affermazione:

 case Terminated(c) 

Corrispondiamo a tutti i messaggi Terminati con qualsiasi riferimento a ActorRef mappato in c .