Scala for Backend Engineering & Functional Programming · Pelajaran

Desugaring for

map dan flatMap.

Desugaring for adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 1 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 For-komprehensi?

For-komprehensi dalam Scala adalah sintaks khusus untuk bekerja dengan koleksi dan tipe wadah lainnya. Bentuknya menyerupai perulangan imperatif, tetapi sebenarnya merupakan gula sintaksis yang ditulis ulang oleh kompilator menjadi pemanggilan map, flatMap, filter, dan foreach.

Memahami perubahan bentuk ini membantu Anda menalar setiap for-komprehensi, termasuk yang menggunakan tipe khusus.

object Main {
  def main(args: Array[String]): Unit = {
    val result = for (x <- List(1, 2, 3)) yield x * 10
    println(result)
  }
}

Satu Generator Menjadi map

Ketika sebuah for-komprehensi memiliki tepat satu generator dan menggunakan yield, kompilator menulis ulang komprehensi tersebut menjadi satu pemanggilan map.

for (x <- xs) yield f(x)
menjadi xs.map(x => f(x))

object Main {
  def main(args: Array[String]): Unit = {
    val a = for (x <- List(1, 2, 3)) yield x + 1
    val b = List(1, 2, 3).map(x => x + 1)
    println(a == b)
  }
}

Kata Kunci yield

Kata kunci yield memberi tahu Scala untuk mengumpulkan hasil ke dalam koleksi baru dengan jenis yang sama.

Tanpa yield, for-komprehensi menjalankan efek samping untuk setiap elemen dan mengembalikan Unit (menjadi foreach).

object Main {
  def main(args: Array[String]): Unit = {
    // No yield: side effect only
    for (x <- List("a", "b")) println(x)
    // With yield: builds a new List
    val upper = for (x <- List("a", "b")) yield x.toUpperCase
    println(upper)
  }
}

Dua Generator Menjadi flatMap + map

Dengan dua generator atau lebih, generator bagian luar menjadi flatMap dan generator paling dalam menjadi map.

for (x <- xs; y <- ys) yield f(x, y)
menjadi xs.flatMap(x => ys.map(y => f(x, y)))

object Main {
  def main(args: Array[String]): Unit = {
    val pairs = for {
      x <- List(1, 2)
      y <- List("a", "b")
    } yield (x, y)
    println(pairs)
  }
}

Melihat flatMap yang Setara

Di sini kita menulis logika yang sama dengan kedua cara. Membuktikan bahwa keduanya setara menunjukkan bahwa for-komprehensi tidak menambahkan keajaiban apa pun, melainkan hanya keterbacaan.

object Main {
  def main(args: Array[String]): Unit = {
    val sugar = for {
      x <- List(1, 2)
      y <- List(10, 20)
    } yield x + y

    val desugared = List(1, 2).flatMap(x => List(10, 20).map(y => x + y))

    println(sugar)
    println(sugar == desugared)
  }
}

Mengapa flatMap untuk Generator Luar

Setiap elemen luar menghasilkan seluruh koleksi hasil bagian dalam. Jika kita menggunakan map untuk generator luar, kita akan mendapatkan koleksi bertingkat seperti List(List(...), List(...)).

flatMap meratakan daftar bertingkat tersebut menjadi satu hasil datar.

object Main {
  def main(args: Array[String]): Unit = {
    val nested = List(1, 2).map(x => List(10, 20).map(y => x + y))
    val flat   = List(1, 2).flatMap(x => List(10, 20).map(y => x + y))
    println(nested)
    println(flat)
  }
}

for tanpa yield adalah foreach

Perulangan for tanpa yield ditulis ulang menjadi foreach. Perulangan ini menjalankan isi untuk efek sampingnya dan menghasilkan Unit.

for (x <- xs) doSomething(x)
menjadi xs.foreach(x => doSomething(x))

object Main {
  def main(args: Array[String]): Unit = {
    val r: Unit = for (x <- List(1, 2, 3)) print(x + " ")
    println()
    println("Return type is Unit")
  }
}

Tipe Hasil Mengikuti Generator Pertama

Tipe hasil ditentukan oleh koleksi generator pertama. For atas sebuah List menghasilkan List; atas sebuah Set, menghasilkan Set; atas sebuah Option, menghasilkan Option.

object Main {
  def main(args: Array[String]): Unit = {
    val fromList = for (x <- List(1, 2, 2, 3)) yield x
    val fromSet  = for (x <- Set(1, 2, 2, 3)) yield x
    println(fromList)
    println(fromSet)
  }
}

Mengikat Nilai dengan =

Di dalam for-komprehensi, Anda dapat mengikat nilai perantara dengan =. Ini menghindari perhitungan ulang dan meningkatkan keterbacaan.

Strukturnya diubah menjadi map yang membawa nilai tambahan dalam sebuah tupel.

object Main {
  def main(args: Array[String]): Unit = {
    val result = for {
      x <- List(1, 2, 3)
      doubled = x * 2
    } yield doubled + 1
    println(result)
  }
}

Bekerja pada Tipe Apa Pun yang Memiliki map/flatMap

Karena perubahan bentuk ini hanya bergantung pada map dan flatMap, for-komprehensi dapat digunakan pada tipe apa pun yang mendefinisikan metode tersebut: Option, Either, Try, Future, dan kelas Anda sendiri.

object Main {
  def main(args: Array[String]): Unit = {
    val combined = for {
      a <- Some(2)
      b <- Some(3)
    } yield a * b
    println(combined)
  }
}

Keterbacaan adalah Keuntungan Utamanya

Bandingkan rangkaian flatMap/map yang sangat bertingkat dengan for-komprehensi yang rapi. Keduanya dikompilasi menjadi hal yang sama, tetapi versi for dibaca dari atas ke bawah seperti resep.

object Main {
  def main(args: Array[String]): Unit = {
    val chained = List(1, 2).flatMap(a => List(3, 4).map(b => a * b))
    val readable = for {
      a <- List(1, 2)
      b <- List(3, 4)
    } yield a * b
    println(chained == readable)
  }
}

Pemeriksaan Singkat

Bagaimana kompilator mengubah for-komprehensi dengan dua generator dan sebuah yield?

Ringkasan

Anda telah mempelajari cara for-komprehensi diubah:

Satu generator + yield → map
Beberapa generator + yield → flatMap (luar) + map (dalam)
Tanpa yield → foreach yang mengembalikan Unit
Pengikatan val = menambahkan nilai perantara
Tipe hasil mengikuti generator pertama

Tipe apa pun yang memiliki map dan flatMap dapat digunakan dalam for-komprehensi.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Desugaring for” gratis?

Ya — teks lengkap “Desugaring for” 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 “Desugaring for”?

map dan flatMap. 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 1 dari 4.

Berapa lama pelajaran “Desugaring for” 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.

Semua pelajaran dalam kursus ini

← Kembali ke Scala for Backend Engineering & Functional Programming