Kotlin Academy · Lektion

Funktionel domænemodellering med Arrows kernetyper

Modellér komplekse domæner med Either, NonEmptyList og valideret akkumulering af fejl

Lektion 4 af 413 trin

Funktionel domænemodellering med Arrows kernetyper er en gratis Kotlin Academy-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Kotlin Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Kotlin Academy-kurset indeholder 4 lektioner i alt.

Hvad er funktionel domænemodellering

Funktionel domænemodellering bruger algebraiske typer (Either, Option, forseglede klasser) til at indkode forretningsregler i typer. Ugyldige tilstande kan ikke repræsenteres ved kompileringstid, og fejl er eksplicitte i funktionssignaturer — ingen skjulte undtagelser.

Værdiobjekter med inline-/værdiklasser

Brug Kotlin-værdiklasser til at indpakke primitive typer og forhindre overforbrug af primitive typer. Typesystemet afviser at sende en UserId, når der forventes en PostId:

@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!

Forseglede klasser til domænefejl

Modellér fejl som hierarkier af forseglede klasser. Hver underklasse indeholder kun de data, der er relevante for den pågældende fejltype:

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: Akkumulering af flere fejl

Når du vil rapportere alle valideringsfejl på én gang (ikke kun den første), skal du bruge Arrows Validated (eller zipOrAccumulate i Raise DSL). Fejlene samles i en 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()

Sammensætning af valideringer

Brug zip() til at kombinere flere Validated-resultater. Hvis blot ét resultat er Invalid, samles alle fejl:

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

Gør ugyldige tilstande umulige at repræsentere

I stedet for en User med en nullable email og en markør isVerified kan du bruge forseglede underklasser, så typesystemet forhindrer adgang til mailadressen hos en ikke-verificeret bruger:

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

Smarte konstruktører

Brug fabriksfunktioner i et companion object, der returnerer Either eller Option, i stedet for offentlige konstruktører. Det sikrer, at instanser altid er i en gyldig tilstand:

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

Kombination af Either og Option i et databehandlingsforløb

En reel domæneoperation kæder typisk opslag i repositories (Option) sammen med valideringer (Either). Brug Arrows either { }-blok med .bind() til at sammensætte dem på en enkel måde:

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

Uforanderlighed og copy

Domæneentiteter bør være uforanderlige. Brug dataklasser og copy() til at aflede nye tilstande. Arrows Lens (fra arrow-optics) gør det muligt at foretage ergonomiske indlejrede opdateringer uden at ændre data:

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

Typesikker konfiguration med forseglede klasser

Modellér varianter af applikationskonfigurationen med forseglede klasser, så compileren tvinger dig til at håndtere hvert tilfælde:

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

Fordele på et øjeblik

Funktionel domænemodellering med Arrows kernetyper giver:

Ingen null-pointer-undtagelser i domænekoden
Fejl, der er synlige i funktionssignaturer
Udtømmende when-kontroller på forseglede hierarkier
Testbare rene funktioner
Selvforklarende kode

Hurtigt tjek

Hvad er den primære fordel ved at bruge et sealed class-hierarki til domænefejl frem for at kaste undtagelser?

Besvar den i den interaktive lektion

Opsummering: Funktionel domænemodellering med Arrows kernetyper

Vigtigste pointer:

Værdiklasser forhindrer overforbrug af primitive typer
Forseglede fejlhierarkier gør fejlsituationer udtømmende og typesikre
Smarte konstruktører garanterer gyldige instanser
either { }.bind() sammensætter fejlfølsomme operationer på en enkel måde
Uforanderlige data + copy() / Arrow Optics giver sikre tilstandsovergange

Gratis at komme i gang

Lær Kotlin med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 51
Lektioner: 203

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Funktionel domænemodellering med Arrows kernetyper” gratis?

Ja — alle 3 lektioner i læringssporet Kotlin Academy, inklusive “Funktionel domænemodellering med Arrows kernetyper”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Kotlin Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Funktionel domænemodellering med Arrows kernetyper”?

Modellér komplekse domæner med Either, NonEmptyList og valideret akkumulering af fejl Du øver dig i Kotlin Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Kotlin Academy?

Der kræves ingen tidligere erfaring. Kotlin Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.

Hvor lang tid tager lektionen “Funktionel domænemodellering med Arrows kernetyper”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Kotlin Academy-lektion?

Ja. Alle Kotlin Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Either : Typesikker fejlhåndtering uden exceptions
Arrow Raise DSL: Sammensætning af typede fejl
Option og nullable: Hvornår skal de bruges
Funktionel domænemodellering med Arrows kernetyper

← Tilbage til Kotlin Academy