Kotlin Academy · Leçon

Either<L, R> : gestion typée des erreurs sans exceptions

Utilisez Either pour représenter la réussite et l’échec sans lever d’exceptions.

Leçon 1 sur 413 étapes

Either<L, R> : gestion typée des erreurs sans exceptions est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.

Le problème des exceptions pour la logique métier

Les exceptions sont conçues pour les échecs inattendus (pointeur nul, erreur d'IO). Les utiliser pour signaler des échecs métier prévisibles (échec de validation, « introuvable ») rend le flux de contrôle invisible, impose des blocs try/catch à chaque point d'appel et dissimule les erreurs dans les signatures de fonctions.

Qu'est-ce que Either<L, R>

Either est un type somme à deux cas : Left(value: L) contient conventionnellement l'erreur, tandis que Right(value: R) contient conventionnellement la valeur obtenue en cas de succès. Une fonction qui renvoie Either rend la possibilité d'un échec explicite dans sa signature.

Either d'Arrow

Ajoutez Arrow à votre projet pour obtenir Either et tout son écosystème d'opérateurs :

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

Renvoyer Either depuis une fonction

Renvoyez value.right() en cas de succès et error.left() en cas d'échec. L'appelant doit gérer les deux branches :

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

Utiliser Either avec fold

Utilisez fold(ifLeft, ifRight) pour gérer les deux cas dans une seule expression :

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

Transformer la valeur Right avec map

map { } transforme la valeur de Right sans toucher à Left. Cela fait de Either un foncteur : vous pouvez enchaîner les transformations en toute sécurité :

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

Enchaîner avec flatMap

flatMap { } enchaîne des calculs qui renvoient eux-mêmes Either. Si une étape renvoie Left, la chaîne s'arrête immédiatement et l'erreur est propagée sans exécuter les étapes suivantes :

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 pour encapsuler les exceptions

Either.catch { } exécute un bloc et encapsule toute exception dans un Left. Utilisez-le à la frontière entre l'ancien code qui lève des exceptions et votre domaine fondé sur Either :

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

Récupérer une valeur avec getOrElse et orElse

getOrElse { default } extrait la valeur de Right ou renvoie une valeur par défaut. orElse { alternativeEither } remplace un Left par un autre calcul :

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

Appariement de motifs avec when

Utilisez when sur une classe scellée de type Either, ou directement sur Either avec is Either.Left / Either.Right, afin de traiter tous les cas de manière exhaustive :

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

Either dans les couches de service

Renvoyez Either depuis les fonctions du dépôt et du service. Convertissez-le en réponses HTTP au niveau des routes Ktor, en gardant la logique métier indépendante des préoccupations liées au framework :

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

Vérification rapide

Que fait flatMap { } sur une valeur Either.Left ?

Réponds-y dans la leçon interactive

Récapitulatif : Either<L, R>

Points essentiels :

Either rend le chemin d'échec explicite dans la signature de la fonction
Right = succès ; Left = échec, par convention
map { } — transformer la valeur de succès ; flatMap { } — enchaîner des calculs susceptibles d'échouer
fold(ifLeft, ifRight) — traiter les deux cas dans une seule expression
Either.catch { } — encapsuler le code qui lève des exceptions aux frontières

Gratuit pour commencer

Apprends Kotlin avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 51
Leçons: 203

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Either<L, R> : gestion typée des erreurs sans exceptions » est-elle gratuite ?

Oui — le texte complet de « Either<L, R> : gestion typée des erreurs sans exceptions » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Either<L, R> : gestion typée des erreurs sans exceptions » ?

Utilisez Either pour représenter la réussite et l’échec sans lever d’exceptions. Tu pratiques Kotlin Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Kotlin Academy ?

Aucune expérience préalable n'est requise. Kotlin Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Either<L, R> : gestion typée des erreurs sans exceptions » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Kotlin Academy ?

Oui. Chaque leçon Kotlin Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Either : gestion typée des erreurs sans exceptions
DSL Raise d’Arrow : composer des erreurs typées
Option et nullable : quand utiliser chacun
Modélisation fonctionnelle du domaine avec les types de base d’Arrow

← Retour à Kotlin Academy