Kotlin Academy · Les

Functionele domeinmodellering met de kerntypen van Arrow

Modelleer complexe domeinen met Either, NonEmptyList en gevalideerde foutaccumulatie.

Les 4 van 413 stappen

Functionele domeinmodellering met de kerntypen van Arrow is een gratis Kotlin Academy-les op CoddyKit. Dit is les 4 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.

Wat is functionele domeinmodellering?

Functionele domeinmodellering gebruikt algebraïsche typen (Either, Option, gesloten klassen) om bedrijfsregels in typen vast te leggen. Ongeldige toestanden kunnen tijdens compilatie niet worden uitgedrukt en fouten zijn expliciet in functiesignaturen — geen verborgen uitzonderingen.

Waardeobjecten met inline-/waardeklassen

Gebruik Kotlin-waardeklassen om primitieve typen te omhullen en obsessie met primitieve typen te voorkomen. Het typesysteem weigert een UserId door te geven waar een PostId wordt verwacht:

@JvmInline value class UserId(val value: Long)
@JvmInline value class PostId(val value: Long)

fun findUser(id: UserId): Either<UserError, User> = TODO()
// findUser(PostId(1L))  // Compile error!

Gesloten klassen voor domeinfouten

Modelleer fouten als hiërarchieën van gesloten klassen. Elke subklasse bevat alleen de gegevens die relevant zijn voor dat foutgeval:

sealed class UserError {
    data class NotFound(val id: UserId) : UserError()
    data class EmailTaken(val email: String) : UserError()
    data class ValidationFailed(val field: String, val reason: String) : UserError()
}

Validated: meerdere fouten verzamelen

Wanneer je alle validatiefouten tegelijk wilt rapporteren (niet alleen de eerste), gebruik je Arrow's Validated (of zipOrAccumulate in de Raise DSL). Het verzamelt fouten in een NonEmptyList:

import arrow.core.Validated
import arrow.core.valid
import arrow.core.invalid

fun validateName(name: String): Validated<String, String> =
    if (name.isNotBlank()) name.valid() else "Name is blank".invalid()

Validaties samenstellen

Gebruik zip() om meerdere resultaten van Validated te combineren. Als een van de resultaten Invalid is, worden alle fouten verzameld:

val result: Validated<NonEmptyList<String>, User> =
    validateName(name).zip(validateEmail(email)) { n, e -> User(n, e) }
        .mapLeft { it }

Ongeldige toestanden onuitdrukbaar maken

Gebruik in plaats van een User met een nullable email en een vlag isVerified gesloten subklassen, zodat het typesysteem voorkomt dat je het e-mailadres van een niet-geverifieerde gebruiker benadert:

sealed class User {
    data class Unverified(val id: UserId, val pendingEmail: String) : User()
    data class Verified(val id: UserId, val email: String) : User()
}

Slimme constructors

Gebruik fabrieksfuncties in companion objects die Either of Option teruggeven in plaats van openbare constructors. Zo zorg je ervoor dat instanties altijd een geldige toestand hebben:

class Email private constructor(val value: String) {
    companion object {
        fun of(raw: String): Either<String, Email> =
            if (raw.contains("@") && raw.length <= 255) Email(raw).right()
            else "Invalid email format".left()
    }
}

Either en Option combineren in een pijplijn

Een echte domeinbewerking koppelt doorgaans zoekacties in repositories (Option) aan validaties (Either). Gebruik Arrow's either { }-blok met .bind() om ze vloeiend samen te stellen:

fun createPost(authorId: UserId, title: String, body: String): Either<PostError, Post> = either {
    val author = userRepo.findById(authorId).toEither { PostError.AuthorNotFound }.bind()
    val validTitle = validateTitle(title).bind()
    postRepo.save(Post(author, validTitle, body))
}

Onveranderlijkheid en Copy

Domeinentiteiten moeten onveranderlijk zijn. Gebruik gegevensklassen en copy() om nieuwe toestanden af te leiden. Arrow's Lens (uit arrow-optics) maakt handige geneste wijzigingen mogelijk zonder mutatie:

val updated = user.copy(email = "new@example.com")
// Arrow Optics:
val emailLens = User.email
val updatedWithLens = emailLens.set(user, "new@example.com")

Typeveilige configuratie met gesloten klassen

Modelleer configuratievarianten van de toepassing met gesloten klassen, zodat de compiler je dwingt elk geval af te handelen:

sealed class DbConfig {
    data class Postgres(val url: String, val user: String, val pass: String) : DbConfig()
    data class InMemory(val dbName: String = "test") : DbConfig()
}

Voordelen in één oogopslag

Functionele domeinmodellering met de kerntypen van Arrow levert:

Geen nullpointeruitzonderingen in domeincode
Fouten die zichtbaar zijn in functiesignaturen
Volledige when-controles op hiërarchieën van gesloten klassen
Pure functies die je kunt testen
Zelfdocumenterende code

Korte controle

Wat is het belangrijkste voordeel van een hiërarchie met sealed class voor domeinfouten ten opzichte van het gooien van uitzonderingen?

Beantwoord dit in de interactieve les

Samenvatting: functionele domeinmodellering met de kerntypen van Arrow

Belangrijkste punten:

Waarde klassen voorkomen obsessie met primitieve typen
Hiërarchieën van gesloten foutklassen maken foutgevallen volledig en typeveilig
Slimme constructors garanderen geldige instanties
either { }.bind() stelt bewerkingen die kunnen mislukken netjes samen
Onveranderlijke gegevens + copy() / Arrow Optics voor veilige toestandsovergangen

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 “Functionele domeinmodellering met de kerntypen van Arrow” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Kotlin Academy, waaronder “Functionele domeinmodellering met de kerntypen van Arrow”, 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 “Functionele domeinmodellering met de kerntypen van Arrow”?

Modelleer complexe domeinen met Either, NonEmptyList en gevalideerde foutaccumulatie. 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 4 van 4.

Hoe lang duurt de les “Functionele domeinmodellering met de kerntypen van Arrow”?

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