0Pricing
Kotlin Academy · Pelajaran

DSL Raise Arrow: Menyusun Error Bertipe

Gunakan konteks Raise milik Arrow dan raise() untuk menyusun alur dengan banyak error secara rapi.

DSL Raise Arrow: Menyusun Error Bertipe adalah pelajaran Kotlin Academy 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 Kotlin Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Kotlin Academy mencakup 4 pelajaran total.

Keterbatasan Perangkaian Either

Merangkai Either dengan flatMap menghasilkan lambda yang sangat bertingkat ketika Anda memiliki beberapa operasi berurutan. DSL Raise dari Arrow (diperkenalkan pada Arrow 1.2) menawarkan sintaks yang lebih bersih dan bergaya korutin menggunakan penerima konteks Kotlin atau fungsi ekstensi.

Apa Itu Raise<E>?

Raise adalah konteks yang dapat menaikkan (menghentikan lebih awal dengan) kesalahan bertipe E. Fungsi yang dapat gagal memanggil raise(error) untuk membatalkan dan meneruskan kesalahan, mirip dengan melempar pengecualian tetapi tanpa pengecualian.

Pembuat either { }

Pembuat either { } membuat Either dari blok yang memiliki Raise dalam cakupannya. Di dalamnya, Anda menggunakan raise(error) untuk kegagalan atau cukup mengembalikan nilai untuk keberhasilan:

import arrow.core.raise.either
import arrow.core.raise.Raise

fun validateAge(age: Int): Either<String, Int> = either {
    if (age < 0) raise("Age cannot be negative")
    if (age > 150) raise("Age too large")
    age
}

bind() — Membuka Bungkus Either di dalam either{}

Di dalam blok either { }, panggil .bind() pada nilai Either apa pun untuk membuka bungkusnya. Jika nilainya adalah Left, bind() akan otomatis menaikkan kesalahan dan menghentikan blok lebih awal:

fun createUser(name: String, age: Int): Either<String, User> = either {
    val validName = validateName(name).bind()  // raises if Left
    val validAge  = validateAge(age).bind()    // raises if Left
    User(validName, validAge)                  // only reached if both succeed
}

ensure() — Pemeriksaan Kondisi Sebaris

ensure(condition) { error } adalah bentuk singkat dari if (!condition) raise(error). Ini membuat logika validasi tetap ringkas:

fun validateEmail(email: String): Either<String, String> = either {
    ensure(email.contains("@")) { "Email must contain @" }
    ensure(email.length <= 255) { "Email too long" }
    email
}

ensureNotNull() — Pemeriksaan Null dengan Raise

ensureNotNull(value) { error } membuka bungkus nilai yang dapat bernilai null atau menaikkan kesalahan jika nilainya null:

fun findUser(id: Long, repo: UserRepo): Either<UserError, User> = either {
    ensureNotNull(repo.findById(id)) { UserError.NotFound(id) }
}

Raise dengan Penerima Konteks (Arrow 1.2+)

Anda dapat mendeklarasikan fungsi yang secara langsung memerlukan konteks Raise, tanpa membungkusnya dalam either { }:

context(Raise<String>)
fun requirePositive(n: Int): Int {
    ensure(n > 0) { "Must be positive" }
    return n
}

// Called inside either { }
val result = either { requirePositive(-1) }  // Left("Must be positive")

Mengumpulkan Kesalahan dengan zipOrAccumulate

Secara default, Raise berhenti pada kesalahan pertama. Gunakan zipOrAccumulate() untuk menjalankan beberapa validasi dan mengumpulkan semua kesalahan ke dalam NonEmptyList:

val result: Either<NonEmptyList<String>, User> = either {
    zipOrAccumulate(
        { validateName(name).bind() },
        { validateAge(age).bind() }
    ) { validName, validAge -> User(validName, validAge) }
}

recover { } — Menangani Kesalahan Tertentu

Gunakan recover { error -> ... } di dalam either { } untuk menangani kesalahan tertentu yang dinaikkan dan menyediakan nilai cadangan, lalu melanjutkan komputasi:

val name: String = either {
    findUser(0L).bind().name
}.recover { error ->
    if (error == UserError.NotFound) "Guest" else raise(error)
}.getOrNull() ?: "Guest"

Raise vs Perangkaian Either: Kapan Menggunakan Masing-Masing

Gunakan either { }.bind() untuk alur linear dengan beberapa langkah berurutan — kode tersebut terbaca seperti kode imperatif tetapi tetap murni. Gunakan perangkaian flatMap untuk komposisi singkat dua langkah atau ketika menggabungkannya dengan pustaka fungsional lain.

Menguji Fungsi Berbasis Raise

Uji dengan memanggil fungsi di dalam either { } dan memeriksa hasilnya. Pencocok Kotest shouldBeLeft() dan shouldBeRight() dari Arrow membuat pemeriksaan menjadi ringkas:

import arrow.core.shouldBeLeft
import arrow.core.shouldBeRight

@Test
fun `negative age returns Left`() {
    validateAge(-1).shouldBeLeft()
}

@Test
fun `valid age returns Right`() {
    validateAge(25).shouldBeRight(25)
}

Pemeriksaan Singkat

Di dalam blok either { }, apa yang terjadi ketika Anda memanggil .bind() pada nilai Either.Left?

Ringkasan: DSL Raise Arrow

Poin-poin penting:

  • either { } membuat Either dari blok dengan Raise dalam cakupannya
  • .bind() membuka bungkus Either; berhenti lebih awal saat menerima Left
  • ensure(condition) { error } dan ensureNotNull(value) { error } untuk pemeriksaan sebaris
  • zipOrAccumulate() untuk mengumpulkan beberapa kesalahan, bukan berhenti lebih awal
  • Terbaca seperti kode imperatif namun tetap sepenuhnya fungsional

Pertanyaan yang Sering Diajukan

Apakah pelajaran “DSL Raise Arrow: Menyusun Error Bertipe” gratis?

Ya — teks lengkap “DSL Raise Arrow: Menyusun Error Bertipe” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Kotlin Academy, upgrade ke CoddyKit PRO. Kursus Kotlin Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “DSL Raise Arrow: Menyusun Error Bertipe”?

Gunakan konteks Raise milik Arrow dan raise() untuk menyusun alur dengan banyak error secara rapi. Kamu berlatih Kotlin Academy 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 Kotlin Academy?

Tidak diperlukan pengalaman sebelumnya. Kotlin Academy 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 “DSL Raise Arrow: Menyusun Error Bertipe” 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 Kotlin Academy ini?

Ya. Setiap pelajaran Kotlin Academy 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

  1. Either : Penanganan Error Bertipe Tanpa Exception
  2. DSL Raise Arrow: Menyusun Error Bertipe
  3. Option dan Nullable: Kapan Menggunakan Masing-Masing
  4. Pemodelan Domain Fungsional dengan Tipe Inti Arrow
← Kembali ke Kotlin Academy