Kotlin Academy · Pelajaran

Either<L, R>: Penanganan Error Bertipe Tanpa Exception

Gunakan Either untuk merepresentasikan keberhasilan dan kegagalan tanpa melempar pengecualian.

Either<L, R>: Penanganan Error Bertipe Tanpa Exception adalah pelajaran Kotlin Academy 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 Kotlin Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Kotlin Academy mencakup 4 pelajaran total.

Masalah Penggunaan Pengecualian untuk Logika Bisnis

Pengecualian dirancang untuk kegagalan yang tidak terduga (penunjuk null, kesalahan IO). Menggunakannya untuk menandai kegagalan bisnis yang diharapkan (kegagalan validasi, "tidak ditemukan") membuat alur kontrol tidak terlihat, memaksa Anda menulis try/catch di setiap lokasi pemanggilan, dan menyembunyikan kesalahan dalam tanda tangan fungsi.

Apa Itu Either<L, R>?

Either adalah tipe gabungan dengan dua kasus: Left(value: L) secara konvensional menyimpan kesalahan, sedangkan Right(value: R) secara konvensional menyimpan nilai keberhasilan. Fungsi yang mengembalikan Either menjadikan kemungkinan kegagalan terlihat jelas dalam tanda tangannya.

Either milik Arrow

Tambahkan Arrow ke proyek Anda untuk mendapatkan Either dan seluruh ekosistem operatornya:

// build.gradle.kts
implementation("io.arrow-kt:arrow-core:1.2.4")

// Usage
import arrow.core.Either
import arrow.core.left
import arrow.core.right

Mengembalikan Either dari Fungsi

Kembalikan value.right() untuk keberhasilan dan error.left() untuk kegagalan. Pemanggil harus menangani kedua cabang:

sealed class UserError { object NotFound : UserError(); data class InvalidEmail(val msg: String) : UserError() }

fun findUser(id: Long): Either<UserError, User> =
    if (id <= 0) UserError.NotFound.left()
    else User(id, "Alice").right()

Menggunakan Either dengan fold

Gunakan fold(ifLeft, ifRight) untuk menangani kedua kasus dalam satu ekspresi:

val result = findUser(1L)
val message = result.fold(
    ifLeft  = { error -> "Error: $error" },
    ifRight = { user  -> "Found: ${user.name}" }
)
println(message)

Mengubah Nilai Right dengan map

map { } mengubah nilai Right tanpa menyentuh Left. Dengan demikian, Either menjadi funktor — Anda dapat merangkai transformasi dengan aman:

val nameResult: Either<UserError, String> = findUser(1L).map { it.name }

Merangkai dengan flatMap

flatMap { } merangkai komputasi yang juga mengembalikan Either. Jika salah satu langkah mengembalikan Left, rangkaian akan berhenti lebih awal dan kesalahan diteruskan tanpa menjalankan langkah-langkah berikutnya:

fun validateEmail(email: String): Either<UserError, String> =
    if (email.contains("@")) email.right()
    else UserError.InvalidEmail("bad format").left()

fun createUser(email: String): Either<UserError, User> =
    validateEmail(email).flatMap { validEmail ->
        User(1L, validEmail).right()
    }

Either.catch untuk Membungkus Pengecualian

Either.catch { } menjalankan sebuah blok dan membungkus pengecualian apa pun sebagai Left. Gunakan ini pada batas antara kode lama yang melempar pengecualian dan ranah Anda yang berbasis Either:

val result: Either<Throwable, User> = Either.catch {
    userRepository.findOrThrow(id)
}

Memulihkan dengan getOrElse dan orElse

getOrElse { default } mengekstrak nilai Right atau mengembalikan nilai cadangan. orElse { alternativeEither } mengganti Left dengan komputasi lain:

val user: User = findUser(0L).getOrElse { User(-1L, "Guest") }
val user2: Either<UserError, User> = findUser(0L).orElse { User(99L, "Default").right() }

Pencocokan Pola dengan when

Gunakan when pada kelas mirip Either yang sealed atau langsung pada Either dengan is Either.Left / Either.Right untuk menangani semua kasus secara menyeluruh:

when (val r = findUser(1L)) {
    is Either.Left  -> println("Error: ${r.value}")
    is Either.Right -> println("User: ${r.value.name}")
}

Either pada Lapisan Layanan

Kembalikan Either dari fungsi repositori dan layanan. Petakan hasilnya ke respons HTTP pada tingkat rute Ktor, sehingga logika bisnis tetap bebas dari hal-hal terkait kerangka kerja:

get("/users/{id}") {
    val id = call.parameters["id"]?.toLongOrNull() ?: return@get call.respond(HttpStatusCode.BadRequest)
    userService.findById(id).fold(
        ifLeft  = { call.respond(HttpStatusCode.NotFound) },
        ifRight = { call.respond(it) }
    )
}

Pemeriksaan Singkat

Apa yang dilakukan flatMap { } pada nilai Either.Left?

Ringkasan: Either<L, R>

Poin-poin penting:

Either menjadikan jalur kegagalan terlihat jelas dalam tanda tangan fungsi
Right = berhasil; Left = gagal (secara konvensional)
map { } — mengubah nilai keberhasilan; flatMap { } — merangkai komputasi yang dapat gagal
fold(ifLeft, ifRight) — menangani kedua kasus dalam satu ekspresi
Either.catch { } — membungkus kode yang melempar pengecualian pada batas-batas sistem

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Either<L, R>: Penanganan Error Bertipe Tanpa Exception” gratis?

Ya — teks lengkap “Either<L, R>: Penanganan Error Bertipe Tanpa Exception” 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 “Either<L, R>: Penanganan Error Bertipe Tanpa Exception”?

Gunakan Either untuk merepresentasikan keberhasilan dan kegagalan tanpa melempar pengecualian. 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 1 dari 4.

Berapa lama pelajaran “Either<L, R>: Penanganan Error Bertipe Tanpa Exception” 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

Either : Penanganan Error Bertipe Tanpa Exception
DSL Raise Arrow: Menyusun Error Bertipe
Option dan Nullable: Kapan Menggunakan Masing-Masing
Pemodelan Domain Fungsional dengan Tipe Inti Arrow

← Kembali ke Kotlin Academy