Currying
Applicazione parziale
Currying è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Scala for Backend Engineering & Functional Programming, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.
Che cos'è il currying?
Il currying trasforma una funzione con più argomenti in una catena di funzioni, ognuna delle quali accetta un solo argomento. In Scala si scrive usando più liste di parametri.
object Main {
def add(a: Int)(b: Int): Int = a + b
def main(args: Array[String]): Unit = {
println(add(3)(4))
}
}Più liste di parametri
Un metodo con currying ha più liste di parametri: def f(a: Int)(b: Int). Lo si chiama fornendo ogni lista in successione: f(1)(2).
object Main {
def combine(prefix: String)(value: Int): String = s"$prefix$value"
def main(args: Array[String]): Unit = {
println(combine("id-")(42))
}
}Applicazione parziale
È possibile applicare solo alcune liste di argomenti e ottenere una funzione in attesa dei restanti. Questa operazione si chiama applicazione parziale.
object Main {
def add(a: Int)(b: Int): Int = a + b
def main(args: Array[String]): Unit = {
val addFive = add(5) _
println(addFive(10))
println(addFive(20))
}
}Specializzare una funzione generale
L'applicazione parziale consente di creare funzioni specializzate a partire da una funzione generale, riducendo le ripetizioni.
object Main {
def power(exp: Int)(base: Int): Int = math.pow(base, exp).toInt
def main(args: Array[String]): Unit = {
val square = power(2) _
val cube = power(3) _
println(square(5))
println(cube(2))
}
}Applicare il currying a una funzione normale
Un normale valore di funzione dispone di un metodo .curried che lo converte nella forma con currying.
object Main {
def main(args: Array[String]): Unit = {
val add = (a: Int, b: Int) => a + b
val curriedAdd = add.curried
println(curriedAdd(3)(4))
}
}Rimuovere il currying
L'helper Function.uncurried annulla il processo, trasformando una funzione con currying in una funzione con un'unica lista di parametri.
object Main {
def main(args: Array[String]): Unit = {
val curried: Int => Int => Int = a => b => a + b
val normal = Function.uncurried(curried)
println(normal(3, 4))
}
}Perché il currying è utile
Il currying favorisce il riutilizzo: è possibile fissare una volta i primi argomenti e poi chiamare molte volte il risultato con argomenti rimanenti diversi. Inoltre aiuta il compilatore a inferire i tipi nelle liste successive.
object Main {
def discount(rate: Double)(price: Double): Double = price * (1 - rate)
def main(args: Array[String]): Unit = {
val blackFriday = discount(0.3) _
println(blackFriday(100))
println(blackFriday(250))
}
}Inferenza dei tipi nell'ultima lista
Un motivo pratico per usare più liste di parametri è che il compilatore può inferire i tipi dei parametri della lambda dalle liste precedenti, consentendo di ometterli.
object Main {
def fold[A](xs: List[A])(init: A)(op: (A, A) => A): A =
xs.foldLeft(init)(op)
def main(args: Array[String]): Unit = {
val total = fold(List(1, 2, 3))(0)((a, b) => a + b)
println(total)
}
}Currying con tre liste
È possibile avere un numero qualsiasi di liste di parametri. Ogni chiamata fornisce una lista e restituisce una funzione per quella successiva.
object Main {
def make(a: Int)(b: Int)(c: Int): Int = a + b + c
def main(args: Array[String]): Unit = {
println(make(1)(2)(3))
val step = make(10) _
println(step(20)(30))
}
}Creare validatori configurabili
Un uso comune nella pratica consiste nell'applicare il currying a una regola di validazione, fissare la soglia e riutilizzare il predicato risultante su un dataset.
object Main {
def atLeast(min: Int)(value: Int): Boolean = value >= min
def main(args: Array[String]): Unit = {
val adult = atLeast(18) _
println(List(15, 21, 18, 12).map(adult))
}
}Currying e applicazione parziale
Il currying è la trasformazione strutturale in funzioni con un solo argomento. L'applicazione parziale consiste nel fornire alcuni argomenti subito e i restanti in seguito. Le funzioni con currying rendono naturale l'applicazione parziale.
object Main {
def greet(greeting: String)(name: String): String = s"$greeting, $name!"
def main(args: Array[String]): Unit = {
val sayHi = greet("Hi") _
println(sayHi("Ann"))
println(sayHi("Bob"))
}
}Verifica rapida
Come si definisce un metodo con currying in Scala?
Riepilogo
Ha appreso il currying e l'applicazione parziale:
- I metodi con currying usano più liste di parametri:
f(a)(b) - Applichi parzialmente con
f(x) _per ottenere una nuova funzione .curriedeFunction.uncurriedconvertono le due forme- Favorisce il riutilizzo, la specializzazione e l'inferenza dei tipi
Domande Frequenti
La lezione «Currying» è gratuita?
Sì — il testo completo di «Currying» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Scala for Backend Engineering & Functional Programming, passa a CoddyKit PRO. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.
Cosa imparerò in «Currying»?
Applicazione parziale Eserciti Scala for Backend Engineering & Functional Programming con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Scala for Backend Engineering & Functional Programming?
Non è richiesta alcuna esperienza precedente. Scala for Backend Engineering & Functional Programming su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.
Quanto tempo richiede la lezione «Currying»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Scala for Backend Engineering & Functional Programming?
Sì. Ogni lezione Scala for Backend Engineering & Functional Programming include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.