Currying
Partiel anvendelse
Currying er en gratis Scala til backendudvikling og funktionel programmering-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Scala til backendudvikling og funktionel programmering, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Scala til backendudvikling og funktionel programmering-kurset indeholder 4 lektioner i alt.
Hvad er currying?
Currying omdanner en funktion med flere argumenter til en kæde af funktioner, der hver tager ét argument. I Scala skrives dette med flere parameterlister.
object Main {
def add(a: Int)(b: Int): Int = a + b
def main(args: Array[String]): Unit = {
println(add(3)(4))
}
}Flere parameterlister
En curried metode har flere parameterlister: def f(a: Int)(b: Int). Du kalder den ved at angive hver liste efter tur: 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))
}
}Delvis anvendelse
Du kan anvende kun nogle argumentlister og få en funktion tilbage, der venter på resten. Det kaldes delvis anvendelse.
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))
}
}Specialisering af en generel funktion
Delvis anvendelse lader dig opbygge specialiserede funktioner ud fra en generel funktion, så gentagelser reduceres.
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))
}
}Currying af en almindelig funktion
En almindelig funktionsværdi har en .curried-metode, der omdanner den til curried form.
object Main {
def main(args: Array[String]): Unit = {
val add = (a: Int, b: Int) => a + b
val curriedAdd = add.curried
println(curriedAdd(3)(4))
}
}Ophævelse af currying
Hjælpefunktionen Function.uncurried vender processen om og omdanner en curried funktion til en funktion med én parameterliste.
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))
}
}Hvorfor er currying nyttigt?
Currying gør genbrug muligt: fastlæg de første argumenter én gang, og kald derefter resultatet mange gange med forskellige resterende argumenter. Det hjælper også compileren med at udlede typer i senere lister.
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))
}
}Typeudledning i den sidste liste
En praktisk grund til flere parameterlister er, at compileren kan udlede lambdaens parametertyper fra tidligere lister, så du kan udelade dem.
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 med tre lister
Du kan have så mange parameterlister, du ønsker. Hvert kald leverer én liste og returnerer en funktion til den næste.
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))
}
}Opbygning af konfigurerbare valideringer
En almindelig anvendelse i praksis er at curry en valideringsregel, fastlægge grænsen og genbruge det resulterende prædikat på tværs af et datasæt.
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 kontra delvis anvendelse
Currying er den strukturelle omdannelse til funktioner med ét argument. Delvis anvendelse er handlingen at angive nogle argumenter nu og resten senere. Curried funktioner gør delvis anvendelse naturlig.
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"))
}
}Hurtigt tjek
Hvordan definerer du en curried metode i Scala?
Opsummering
Du har lært om currying og delvis anvendelse:
- Curried metoder bruger flere parameterlister:
f(a)(b) - Anvend delvist med
f(x) _for at få en ny funktion .curriedogFunction.uncurriedomdanner mellem formerne- Det hjælper med genbrug, specialisering og typeudledning
Lær Scala med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 39
- Lektioner
- 143
Ofte stillede spørgsmål
Er lektionen “Currying” gratis?
Ja — hele teksten til “Currying” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Scala til backendudvikling og funktionel programmering-kurset, skal du opgradere til CoddyKit PRO. Scala til backendudvikling og funktionel programmering-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Currying”?
Partiel anvendelse Du øver dig i Scala til backendudvikling og funktionel programmering med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Scala til backendudvikling og funktionel programmering?
Der kræves ingen tidligere erfaring. Scala til backendudvikling og funktionel programmering på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.
Hvor lang tid tager lektionen “Currying”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Scala til backendudvikling og funktionel programmering-lektion?
Ja. Alle Scala til backendudvikling og funktionel programmering-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.