Kotlin Academy · Les

Either<L, R>: getypeerde foutafhandeling zonder exceptions

Gebruik Either om succes en mislukking weer te geven zonder exceptions te gooien.

Les 1 van 413 stappen

Either<L, R>: getypeerde foutafhandeling zonder exceptions is een gratis Kotlin Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Kotlin Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Kotlin Academy bevat in totaal 4 lessen.

Het probleem met uitzonderingen voor bedrijfslogica

Uitzonderingen zijn bedoeld voor onverwachte fouten (nullpointer, IO-fout). Als je ze gebruikt om verwachte bedrijfsfouten te signaleren (validatiefout, "niet gevonden"), wordt de besturingsstroom onzichtbaar, moet je op elke aanroepplek try/catch gebruiken en worden fouten verborgen in de handtekeningen van functies.

Wat is Either<L, R>?

Either is een somtype met twee gevallen: Left(value: L) bevat volgens conventie de fout en Right(value: R) bevat volgens conventie de succeswaarde. Een functie die Either teruggeeft, maakt de mogelijkheid op mislukking expliciet in de handtekening.

Either van Arrow

Voeg Arrow aan je project toe om Either en het volledige ecosysteem van operatoren te krijgen:

// 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 vanuit een functie teruggeven

Geef value.right() terug bij succes en error.left() bij mislukking. De aanroeper moet beide takken afhandelen:

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 verwerken met fold

Gebruik fold(ifLeft, ifRight) om beide gevallen in één expressie af te handelen:

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

De Right-waarde transformeren met map

map { } transformeert de Right-waarde zonder een Left aan te raken. Hierdoor is Either een functor — je kunt transformaties veilig aan elkaar koppelen:

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

Koppelen met flatMap

flatMap { } koppelt berekeningen aan elkaar die zelf Either teruggeven. Als een stap Left teruggeeft, wordt de keten voortijdig afgebroken en wordt de fout doorgegeven zonder de volgende stappen uit te voeren:

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 voor het omwikkelen van uitzonderingen

Either.catch { } voert een blok uit en verpakt elke uitzondering als een Left<Throwable>. Gebruik dit op de grens tussen oude code die uitzonderingen gooit en je op Either gebaseerde domein:

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

Herstellen met getOrElse en orElse

getOrElse { default } haalt de Right-waarde op of geeft een standaardwaarde terug. orElse { alternativeEither } vervangt een Left door een andere berekening:

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

Patroonvergelijking met when

Gebruik when op een sealed Either-achtige klasse of op Either zelf met is Either.Left / Either.Right om alle gevallen af te handelen:

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

Either in servicelagen

Geef Either terug vanuit repository- en servicefuncties. Vertaal dit op routeniveau van Ktor naar HTTP-antwoorden, zodat de bedrijfslogica vrij blijft van frameworkaangelegenheden:

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

Korte controle

Wat doet flatMap { } met een waarde van Either.Left?

Beantwoord dit in de interactieve les

Samenvatting: Either<L, R>

Belangrijkste punten:

Either maakt het foutpad expliciet in de handtekening van de functie
Right = succes; Left = mislukking (volgens conventie)
map { } — de succeswaarde transformeren; flatMap { } — berekeningen die kunnen mislukken aan elkaar koppelen
fold(ifLeft, ifRight) — beide gevallen in één expressie verwerken
Either.catch { } — code die uitzonderingen gooit op grenzen verpakken

Gratis beginnen

Leer Kotlin met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 51
Lessen: 203

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Either<L, R>: getypeerde foutafhandeling zonder exceptions” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Kotlin Academy, waaronder “Either<L, R>: getypeerde foutafhandeling zonder exceptions”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Kotlin Academy bevat in totaal 4 lessen.

Wat leer ik in “Either<L, R>: getypeerde foutafhandeling zonder exceptions”?

Gebruik Either om succes en mislukking weer te geven zonder exceptions te gooien. Je oefent met Kotlin Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Kotlin Academy te beginnen?

Ervaring vooraf is niet nodig. Kotlin Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Either<L, R>: getypeerde foutafhandeling zonder exceptions”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Kotlin Academy?

Ja. Elke les over Kotlin Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Either : getypeerde foutafhandeling zonder exceptions
Arrow Raise DSL: getypeerde fouten samenstellen
Option en Nullable: wanneer gebruikt u welke?
Functionele domeinmodellering met de kerntypen van Arrow

← Terug naar Kotlin Academy