0Pricing
Kotlin Academy · Lektion

Either<L, R>: Typsichere Fehlerbehandlung ohne Exceptions

Verwenden Sie Either, um Erfolg und Fehler darzustellen, ohne Ausnahmen auszulösen.

Either<L, R>: Typsichere Fehlerbehandlung ohne Exceptions ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Kotlin Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Das Problem mit Exceptions für Geschäftslogik

Exceptions sind für unerwartete Fehler vorgesehen (NullPointer, E/A-Fehler). Wenn Sie sie verwenden, um erwartete Geschäftsfehler zu signalisieren (Validierungsfehler, „nicht gefunden“), wird der Kontrollfluss unsichtbar, an jeder Aufrufstelle ein try/catch erzwungen und die Fehlerbehandlung in den Funktionssignaturen verschleiert.

Was ist Either<L, R>?

Either ist ein Summentyp mit zwei Fällen: Left(value: L) enthält konventionell den Fehler, während Right(value: R) konventionell den Erfolgswert enthält. Eine Funktion, die Either zurückgibt, macht die Möglichkeit eines Fehlschlags in ihrer Signatur explizit.

Eithers in Arrow

Fügen Sie Arrow zu Ihrem Projekt hinzu, um Either und sein vollständiges Ökosystem an Operatoren zu erhalten:

// 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

Either aus einer Funktion zurückgeben

Geben Sie bei Erfolg value.right() und bei einem Fehler error.left() zurück. Der Aufrufer muss beide Fälle behandeln:

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()

Either mit fold verarbeiten

Verwenden Sie fold(ifLeft, ifRight), um beide Fälle in einem Ausdruck zu behandeln:

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

Den Right-Wert mit map transformieren

map { } transformiert den Right-Wert, ohne einen Left zu verändern. Dadurch ist Either ein Funktor — Sie können Transformationen sicher verketten:

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

Mit flatMap verketten

flatMap { } verkettet Berechnungen, die selbst Either zurückgeben. Gibt ein Schritt Left zurück, wird die Kette sofort abgebrochen und der Fehler weitergegeben, ohne nachfolgende Schritte auszuführen:

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 zum Verpacken von Exceptions

Either.catch { } führt einen Block aus und verpackt jede Exception als Left. Verwenden Sie es an der Grenze zwischen Legacy-Code, der Exceptions auslöst, und Ihrer auf Either basierenden Domäne:

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

Mit getOrElse und orElse Fehler behandeln

getOrElse { default } extrahiert den Right-Wert oder gibt einen Standardwert zurück. orElse { alternativeEither } ersetzt einen Left durch eine andere Berechnung:

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

Pattern Matching mit when

Verwenden Sie when für eine versiegelte Either-ähnliche Klasse oder direkt für Either mit is Either.Left / Either.Right, um alle Fälle vollständig zu behandeln:

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

Either in Service-Schichten

Geben Sie Either aus Repository- und Service-Funktionen zurück. Wandeln Sie es auf Ebene der Ktor-Route in HTTP-Antworten um, sodass die Geschäftslogik frei von Framework-Abhängigkeiten bleibt:

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) }
    )
}

Kurze Überprüfung

Was bewirkt flatMap { } bei einem Either.Left-Wert?

Zusammenfassung: Either<L, R>

Wichtige Erkenntnisse:

  • Either macht den Fehlerpfad in der Funktionssignatur explizit
  • Right = Erfolg; Left = Fehler (konventionell)
  • map { } — den Erfolgswert transformieren; flatMap { } — fehleranfällige Berechnungen verketten
  • fold(ifLeft, ifRight) — beide Fälle in einem Ausdruck verarbeiten
  • Either.catch { } — Code, der Exceptions auslöst, an den Grenzen verpacken

Häufig gestellte Fragen

Ist die Lektion „Either<L, R>: Typsichere Fehlerbehandlung ohne Exceptions“ kostenlos?

Ja — der vollständige Text von „Either<L, R>: Typsichere Fehlerbehandlung ohne Exceptions“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Kotlin Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Either<L, R>: Typsichere Fehlerbehandlung ohne Exceptions“?

Verwenden Sie Either, um Erfolg und Fehler darzustellen, ohne Ausnahmen auszulösen. Du übst Kotlin Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Kotlin Academy zu starten?

Keine Vorkenntnisse erforderlich. Kotlin Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Either<L, R>: Typsichere Fehlerbehandlung ohne Exceptions“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Kotlin Academy-Lektion Code schreiben und ausführen?

Ja. Jede Kotlin Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Either : Typsichere Fehlerbehandlung ohne Exceptions
  2. Arrow-Raise-DSL: Typisierte Fehler kombinieren
  3. Option und Nullable: Wann Sie welches verwenden
  4. Funktionale Domänenmodellierung mit Arrows Core-Typen
← Zurück zu Kotlin Academy