0Pricing
Kotlin Academy · Leçon

DSL Raise d’Arrow : composer des erreurs typées

Utilisez le contexte Raise d’Arrow et raise() pour composer proprement des flux comportant plusieurs erreurs.

DSL Raise d’Arrow : composer des erreurs typées est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

La limite de l'enchaînement avec Either

Enchaîner des Either avec flatMap crée des fonctions lambda profondément imbriquées lorsque plusieurs opérations séquentielles sont nécessaires. Le DSL Raise d'Arrow, introduit dans Arrow 1.2, offre une syntaxe plus claire, de style coroutine, grâce aux récepteurs de contexte ou aux fonctions d'extension de Kotlin.

Qu'est-ce que Raise<E>

Raise est un contexte qui peut lever une erreur de type E, ce qui interrompt immédiatement le calcul. Une fonction susceptible d'échouer appelle raise(error) pour s'arrêter et propager l'erreur, comme lorsqu'une exception est levée, mais sans exceptions.

Le constructeur either { }

Le constructeur either { } crée un Either à partir d'un bloc qui dispose d'un contexte Raise. À l'intérieur, utilisez raise(error) en cas d'échec ou renvoyez simplement une valeur en cas de succès :

import arrow.core.raise.either
import arrow.core.raise.Raise

fun validateAge(age: Int): Either<String, Int> = either {
    if (age < 0) raise("Age cannot be negative")
    if (age > 150) raise("Age too large")
    age
}

bind() — Déballer Either dans either{}

Dans un bloc either { }, appelez .bind() sur toute valeur Either pour la déballer. S'il s'agit d'un Left, bind() lève automatiquement l'erreur et interrompt le bloc :

fun createUser(name: String, age: Int): Either<String, User> = either {
    val validName = validateName(name).bind()  // raises if Left
    val validAge  = validateAge(age).bind()    // raises if Left
    User(validName, validAge)                  // only reached if both succeed
}

ensure() — Vérification de condition en ligne

ensure(condition) { error } est une forme abrégée de if (!condition) raise(error). Elle permet de garder la logique de validation concise :

fun validateEmail(email: String): Either<String, String> = either {
    ensure(email.contains("@")) { "Email must contain @" }
    ensure(email.length <= 255) { "Email too long" }
    email
}

ensureNotNull() — Vérification de nullité avec Raise

ensureNotNull(value) { error } déballe une valeur nullable ou lève une erreur si elle est nulle :

fun findUser(id: Long, repo: UserRepo): Either<UserError, User> = either {
    ensureNotNull(repo.findById(id)) { UserError.NotFound(id) }
}

Raise avec des récepteurs de contexte (Arrow 1.2+)

Vous pouvez déclarer directement des fonctions qui nécessitent un contexte Raise, sans les envelopper dans either { } :

context(Raise<String>)
fun requirePositive(n: Int): Int {
    ensure(n > 0) { "Must be positive" }
    return n
}

// Called inside either { }
val result = either { requirePositive(-1) }  // Left("Must be positive")

Cumuler les erreurs avec zipOrAccumulate

Par défaut, Raise s'arrête à la première erreur. Utilisez zipOrAccumulate() pour exécuter plusieurs validations et rassembler toutes les erreurs dans une NonEmptyList :

val result: Either<NonEmptyList<String>, User> = either {
    zipOrAccumulate(
        { validateName(name).bind() },
        { validateAge(age).bind() }
    ) { validName, validAge -> User(validName, validAge) }
}

recover { } — Gérer des erreurs précises

Utilisez recover { error -> ... } dans either { } pour traiter une erreur levée précise et fournir une valeur de repli, puis reprendre le calcul :

val name: String = either {
    findUser(0L).bind().name
}.recover { error ->
    if (error == UserError.NotFound) "Guest" else raise(error)
}.getOrNull() ?: "Guest"

Raise ou enchaînement avec Either : quand utiliser chacun

Utilisez either { }.bind() pour les flux linéaires comportant plusieurs étapes successives : le code se lit comme du code impératif tout en restant pur. Utilisez l'enchaînement avec flatMap pour les compositions courtes en deux étapes ou lorsque vous composez avec d'autres bibliothèques fonctionnelles.

Tester les fonctions fondées sur Raise

Testez en appelant la fonction dans either { } et en vérifiant le résultat. Les assertions Kotest shouldBeLeft() et shouldBeRight() d'Arrow rendent les vérifications concises :

import arrow.core.shouldBeLeft
import arrow.core.shouldBeRight

@Test
fun `negative age returns Left`() {
    validateAge(-1).shouldBeLeft()
}

@Test
fun `valid age returns Right`() {
    validateAge(25).shouldBeRight(25)
}

Vérification rapide

Dans un bloc either { }, que fait l'appel de .bind() sur une valeur Either.Left ?

Récapitulatif : DSL Raise d'Arrow

Points essentiels :

  • either { } crée un Either à partir d'un bloc disposant d'un contexte Raise
  • .bind() déballe Either et interrompt le calcul en cas de Left
  • ensure(condition) { error } et ensureNotNull(value) { error } permettent d'effectuer des vérifications en ligne
  • zipOrAccumulate() permet de rassembler plusieurs erreurs au lieu de s'arrêter à la première
  • Le code se lit comme du code impératif tout en restant purement fonctionnel

Questions Fréquemment Posées

La leçon « DSL Raise d’Arrow : composer des erreurs typées » est-elle gratuite ?

Oui — le texte complet de « DSL Raise d’Arrow : composer des erreurs typées » 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 « DSL Raise d’Arrow : composer des erreurs typées » ?

Utilisez le contexte Raise d’Arrow et raise() pour composer proprement des flux comportant plusieurs erreurs. 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 2 sur 4.

Combien de temps prend la leçon « DSL Raise d’Arrow : composer des erreurs typées » ?

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

  1. Either : gestion typée des erreurs sans exceptions
  2. DSL Raise d’Arrow : composer des erreurs typées
  3. Option et nullable : quand utiliser chacun
  4. Modélisation fonctionnelle du domaine avec les types de base d’Arrow
← Retour à Kotlin Academy