Qualcuno può spiegare come viene utilizzato il simbolo "=>" in Scala

Question

Ho letto molti snippet di codice in scala che utilizzano il simbolo =>, ma non sono mai stato in grado di comprenderlo. Ho provato a cercare su internet, ma non ho trovato nulla di completo. Qualsiasi suggerimento/spiegazione su come il simbolo può/può essere utilizzato sarà davvero utile.

(Più specifially, voglio anche sapere come l'operatore entra in foto in letterali funzione)

Answer 1

più dei valori di passaggio/nomi, => è usato per definire una funzione letterale, che è una sintassi alternativa utilizzata per definire una funzione.

Tempo di esempio. Diciamo che hai una funzione che svolge un'altra funzione. Le collezioni ne sono piene, ma sceglieremo lo filter. filter, se utilizzato su una raccolta (come un elenco), eliminerà qualsiasi elemento che causa la funzione fornita dall'utente per restituire false.

val people = List("Bill Nye", "Mister Rogers", "Mohandas Karamchand Gandhi", "Jesus", "Superman", "The newspaper guy") 
// Let's only grab people who have short names (less than 10 characters) 
val shortNamedPeople = people.filter(<a function>) 

Abbiamo potuto passaggio in una funzione reale da qualche altra parte (def isShortName(name: String): Boolean, forse), ma sarebbe più bello di inserire il proprio proprio lì. Ahimè, possiamo, con funzioni letterali.

val shortNamedPeople = people.filter(name => name.length < 10) 

Quello che abbiamo fatto qui è creare una funzione che prende in una stringa (dal people è di tipo List[String]), e restituisce un valore booleano. Piuttosto interessante, vero?

Questa sintassi viene utilizzata in molti contesti. Diciamo che si si desidera scrivere una funzione che accetta un'altra funzione. Questa altra funzione dovrebbe contenere una stringa e restituire un Int.

def myFunction(f: String => Int): Int = { 
    val myString = "Hello!" 
    f(myString) 
} 
// And let's use it. First way: 
def anotherFunction(a: String): Int = { 
    a.length 
} 
myFunction(anotherFunction) 
// Second way: 
myFunction((a: String) => a.length) 

Ecco qual è la funzione letterale. Tornando a by-name e by-value, c'è un trucco in cui è possibile forzare un parametro a non essere valutato fino a quando non si desidera. L'esempio classico:

def logger(message: String) = { 
    if(loggingActivated) println(message) 
} 

Questo sembra a posto, ma in realtà è message valutato quando logger si chiama. Cosa succede se message richiede un po 'di tempo per valutare? Ad esempio, logger(veryLongProcess()), dove veryLongProcess() restituisce una stringa. Urla? Non proprio. Possiamo usare la nostra conoscenza dei letterali di funzione per forzare il veryLongProcess() a non essere chiamato fino a quando non è effettivamente necessario.

def logger(message: => String) = { 
    if(loggingActivated) println(message) 
} 
logger(veryLongProcess()) // Fixed! 

logger sta prendendo in funzioneche non prevede parametri (da qui il nudo => sul lato sinistro). È ancora possibile utilizzarlo come prima, ma ora, message viene valutato solo quando viene utilizzato (nello).