Currying
Aplikasi parsial.
Currying adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Scala for Backend Engineering & Functional Programming, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Scala for Backend Engineering & Functional Programming mencakup 4 pelajaran total.
Apa itu currying?
Currying mengubah fungsi dengan beberapa argumen menjadi rangkaian fungsi yang masing-masing menerima satu argumen. Dalam Scala, hal ini ditulis menggunakan beberapa daftar parameter.
object Main {
def add(a: Int)(b: Int): Int = a + b
def main(args: Array[String]): Unit = {
println(add(3)(4))
}
}Beberapa daftar parameter
Metode curried memiliki beberapa daftar parameter: def f(a: Int)(b: Int). Anda memanggilnya dengan memberikan setiap daftar secara berurutan: 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))
}
}Penerapan parsial
Anda dapat menerapkan hanya sebagian daftar argumen dan mendapatkan fungsi yang menunggu sisanya. Ini disebut penerapan parsial.
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))
}
}Mengkhususkan fungsi umum
Penerapan parsial memungkinkan Anda membuat fungsi khusus dari fungsi umum, sehingga mengurangi pengulangan.
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))
}
}Melakukan currying pada fungsi biasa
Nilai fungsi biasa memiliki metode .curried yang mengubahnya ke bentuk curried.
object Main {
def main(args: Array[String]): Unit = {
val add = (a: Int, b: Int) => a + b
val curriedAdd = add.curried
println(curriedAdd(3)(4))
}
}Mengembalikan ke bentuk non-curried
Pembantu Function.uncurried membalikkan proses tersebut, dengan mengubah fungsi curried kembali menjadi fungsi dengan satu daftar parameter.
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))
}
}Mengapa currying berguna
Currying memungkinkan penggunaan kembali: tetapkan argumen pertama sekali, lalu panggil hasilnya berkali-kali dengan argumen tersisa yang berbeda. Currying juga membantu kompilator menyimpulkan tipe dalam daftar berikutnya.
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))
}
}Inferensi tipe pada daftar terakhir
Alasan praktis untuk menggunakan beberapa daftar parameter adalah kompilator dapat menyimpulkan tipe parameter lambda dari daftar sebelumnya, sehingga Anda dapat menghilangkannya.
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 dengan tiga daftar
Anda dapat memiliki daftar parameter sebanyak yang diinginkan. Setiap pemanggilan memberikan satu daftar dan mengembalikan fungsi untuk daftar berikutnya.
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))
}
}Membangun validator yang dapat dikonfigurasi
Penggunaan nyata yang umum: lakukan currying pada aturan validasi, tetapkan ambang batas, lalu gunakan kembali predikat yang dihasilkan pada seluruh kumpulan data.
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 vs penerapan parsial
Currying adalah transformasi struktural menjadi fungsi-fungsi berargumen tunggal. Penerapan parsial adalah tindakan memberikan sebagian argumen sekarang dan sisanya nanti. Fungsi curried membuat penerapan parsial menjadi alami.
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"))
}
}Pemeriksaan Singkat
Bagaimana cara mendefinisikan metode curried dalam Scala?
Ringkasan
Anda telah mempelajari currying dan penerapan parsial:
- Metode curried menggunakan beberapa daftar parameter:
f(a)(b) - Terapkan sebagian dengan
f(x) _untuk mendapatkan fungsi baru .currieddanFunction.uncurriedmengonversi kedua bentuk- Membantu penggunaan kembali, pengkhususan, dan inferensi tipe
Belajar Scala dengan tutor AI — gratis
Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.
- Kursus
- 39
- Pelajaran
- 143
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Currying” gratis?
Ya — teks lengkap “Currying” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Scala for Backend Engineering & Functional Programming, upgrade ke CoddyKit PRO. Kursus Scala for Backend Engineering & Functional Programming mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Currying”?
Aplikasi parsial. Kamu berlatih Scala for Backend Engineering & Functional Programming dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai Scala for Backend Engineering & Functional Programming?
Tidak diperlukan pengalaman sebelumnya. Scala for Backend Engineering & Functional Programming di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.
Berapa lama pelajaran “Currying” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran Scala for Backend Engineering & Functional Programming ini?
Ya. Setiap pelajaran Scala for Backend Engineering & Functional Programming menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.