Kotlin Academy · leksjon

Funksjonell domenemodellering med Arrow's kjernetyper

Modeller komplekse domener med Either, NonEmptyList og akkumulering av validerte feil.

Leksjon 4 av 413 trinn

Funksjonell domenemodellering med Arrow's kjernetyper er en gratis leksjon i Kotlin Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Kotlin Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Kotlin Academy inneholder totalt 4 leksjoner.

Hva er funksjonell domenemodellering?

Funksjonell domenemodellering bruker algebraiske typer (Either, Option, sealed-klasser) til å kode forretningsregler inn i typer. Ugyldige tilstander blir umulige å representere ved kompilering, og feil er eksplisitte i funksjonssignaturene — ingen skjulte unntak.

Inline-/verdiklasser for value objects

Bruk Kotlin-verdiklasser til å pakke inn primitiver og unngå overdreven bruk av primitive typer. Typesystemet avviser å sende inn en UserId der det 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!

Sealed-klasser for domenefeil

Modeller feil som hierarkier av sealed-klasser. Hver underklasse inneholder bare dataene som er relevante for det aktuelle feilstilfellet:

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 av flere feil

Når du vil rapportere alle valideringsfeil samtidig (ikke bare den første), bruker du Arrow sin Validated (eller zipOrAccumulate i Raise DSL). Den samler feilene 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()

Sette sammen valideringer

Bruk zip() til å kombinere flere Validated-resultater. Hvis noen av dem er Invalid, samles alle feilene opp:

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

Gjør ugyldige tilstander umulige å representere

I stedet for en User med en nullbar email og et flagg isVerified, bruker du sealed-underklasser slik at typesystemet hindrer tilgang til e-postadressen til en ubekreftet bruker:

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

Bruk fabrikkfunksjoner i companion object som returnerer Either eller Option, i stedet for offentlige konstruktører. Dette sikrer at instanser alltid 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()
    }
}

Kombinere Either og Option i en pipeline

En reell domeneoperasjon setter vanligvis sammen oppslag i repositorier (Option) med valideringer (Either). Bruk Arrow sin either { }-blokk med .bind() for å sette dem sammen på en flytende måte:

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

Uforanderlighet og copy()

Domeenheter bør være uforanderlige. Bruk dataklasser og copy() til å utlede nye tilstander. Arrow sin Lens (fra arrow-optics) muliggjør ergonomiske oppdateringer av nøstede verdier uten mutasjon:

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

Typesikker konfigurasjon med sealed-klasser

Modeller varianter av programkonfigurasjonen med sealed-klasser, slik at kompilatoren tvinger deg til å håndtere hvert tilfelle:

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

Fordeler i korte trekk

Funksjonell domenemodellering med Arrow sine kjernetyper gir:

Ingen nullpekerunntak i domenekoden
Feil synlige i funksjonssignaturer
Uttømmende when-kontroller på sealed-hierarkier
Testbare rene funksjoner
Selvdokumenterende kode

Hurtigsjekk

Hva er den viktigste fordelen ved å bruke et sealed class-hierarki for domenefeil fremfor å kaste unntak?

Besvar den i den interaktive leksjonen

Oppsummering: Funksjonell domenemodellering med Arrow sine kjernetyper

Viktige poenger:

Verdiklasser hindrer overdreven bruk av primitive typer
Sealed-feilhierarkier gjør feilstilfellene uttømmende og typesikre
Smarte konstruktører garanterer gyldige instanser
either { }.bind() setter sammen operasjoner som kan mislykkes, på en ryddig måte
Uforanderlige data + copy() / Arrow Optics for sikre tilstandsoverganger

Gratis å komme i gang

Lær deg Kotlin med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 51
Leksjoner: 203

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Funksjonell domenemodellering med Arrow's kjernetyper» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Kotlin Academy, inkludert «Funksjonell domenemodellering med Arrow's kjernetyper», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Kotlin Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Funksjonell domenemodellering med Arrow's kjernetyper»?

Modeller komplekse domener med Either, NonEmptyList og akkumulering av validerte feil. Du øver på Kotlin Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Kotlin Academy?

Ingen tidligere erfaring er nødvendig. Kotlin Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Funksjonell domenemodellering med Arrow's kjernetyper»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Kotlin Academy-leksjonen?

Ja. Alle Kotlin Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Either : Typet feilhåndtering uten exceptions
Arrow Raise DSL: Sammensetting av typede feil
Option og nullable: Når bør De bruke hva
Funksjonell domenemodellering med Arrow's kjernetyper

← Tilbake til Kotlin Academy