Kotlin Academy · Leçon

Hiérarchies Result scellées

Types de résultat personnalisés

Hiérarchies Result scellées est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Au-delà du Result intégré

Le Result de Kotlin ne contient qu’une exception en cas de failure. Vous souhaitez souvent disposer d’informations d’erreur plus riches et typées. Une hiérarchie de classes scellées vous permet de modéliser précisément les résultats possibles dans votre domaine.

Un Outcome scellé

Définissez un type scellé avec des sous-classes de success et d’erreur. Le compilateur connaît tous les cas, ce qui permet une gestion exhaustive.

sealed class Outcome<out T> {
    data class Ok<T>(val value: T) : Outcome<T>()
    data class Err(val message: String) : Outcome<Nothing>()
}

fun main() {
    val r: Outcome<Int> = Outcome.Ok(5)
    println(r)
}

Expression conditionnelle exhaustive

Comme le type est scellé, une expression when qui l’examine n’a pas besoin de else, et le compilateur impose la gestion de chaque cas.

sealed class Outcome<out T> {
    data class Ok<T>(val value: T) : Outcome<T>()
    data class Err(val message: String) : Outcome<Nothing>()
}

fun describe(o: Outcome<Int>) = when (o) {
    is Outcome.Ok -> "value " + o.value
    is Outcome.Err -> "error " + o.message
}

fun main() {
    println(describe(Outcome.Ok(9)))
    println(describe(Outcome.Err("boom")))
}

Variantes d’erreur typées

Modélisez les différentes catégories de failure sous forme de sous-classes distinctes, chacune contenant les données pertinentes. Cette approche est préférable à une exception unique et opaque.

sealed class Fetch<out T> {
    data class Success<T>(val data: T) : Fetch<T>()
    data class NotFound(val id: Int) : Fetch<Nothing>()
    data class Network(val code: Int) : Fetch<Nothing>()
}

fun main() {
    val r: Fetch<String> = Fetch.NotFound(42)
    println(r)
}

Gérer chaque variante

Un when peut réagir précisément à chaque type d’erreur, avec toutes les données disponibles pour chaque branche.

sealed class Fetch<out T> {
    data class Success<T>(val data: T) : Fetch<T>()
    data class NotFound(val id: Int) : Fetch<Nothing>()
    data class Network(val code: Int) : Fetch<Nothing>()
}

fun handle(f: Fetch<String>) = when (f) {
    is Fetch.Success -> "data: " + f.data
    is Fetch.NotFound -> "missing id " + f.id
    is Fetch.Network -> "net error " + f.code
}

fun main() {
    println(handle(Fetch.Network(503)))
}

L’astuce Nothing

Les variantes d’erreur qui ne contiennent aucune valeur de success utilisent Outcome<Nothing>. Comme Nothing est un sous-type de chaque type et que le générique est out, une erreur convient à n’importe quel Outcome<T>.

sealed class Res<out T> {
    data class Ok<T>(val v: T) : Res<T>()
    object Empty : Res<Nothing>()
}

fun get(flag: Boolean): Res<String> =
    if (flag) Res.Ok("hi") else Res.Empty

fun main() {
    println(get(false))
}

Un object pour les cas sans état

Si une variante d’erreur ne contient aucune donnée, déclarez-la comme singleton object plutôt que comme classe.

sealed class Login {
    data class Success(val user: String) : Login()
    object WrongPassword : Login()
    object Locked : Login()
}

fun main() {
    val r: Login = Login.WrongPassword
    println(r === Login.WrongPassword)
}

Renvoyer la hiérarchie

Les fonctions renvoient le type scellé ; les appelants doivent traiter chaque résultat possible, ce qui élimine les chemins d’erreur oubliés.

sealed class Parsed {
    data class Num(val value: Int) : Parsed()
    data class Bad(val input: String) : Parsed()
}

fun parse(s: String): Parsed {
    val n = s.toIntOrNull()
    return if (n != null) Parsed.Num(n) else Parsed.Bad(s)
}

fun main() {
    when (val r = parse("x")) {
        is Parsed.Num -> println(r.value)
        is Parsed.Bad -> println("bad: " + r.input)
    }
}

Result scellé ou Result intégré

Utilisez le Result intégré pour une capture rapide fondée sur les exceptions. Utilisez une hiérarchie scellée personnalisée lorsque vous avez besoin de plusieurs cas d’erreur typés, avec des données propres au domaine et une gestion exhaustive.

Concevoir la hiérarchie

Une bonne conception de résultat scellé comporte :

Une variante de success contenant la charge utile
Une sous-classe pour chaque mode de failure pertinent
La covariance out T, avec Nothing pour les cas qui ne contiennent qu’une erreur

Le compilateur comme filet de sécurité

Le principal avantage est le suivant : lorsque vous ajoutez une nouvelle variante, chaque expression when non exhaustive devient une erreur de compilation qui vous indique chaque emplacement devant la gérer. Les erreurs ne peuvent pas passer inaperçues.

Vérification rapide

Évaluez votre compréhension des hiérarchies de résultats scellées.

Récapitulatif

Vous avez créé des hiérarchies de résultats scellées :

Un success accompagné de variantes d’erreur typées
Une expression when exhaustive sans else
out T et Nothing pour les cas qui ne contiennent qu’une erreur
Une gestion des nouvelles variantes imposée par le compilateur

Ensuite : la gestion fonctionnelle des erreurs avec map et recover.

Questions Fréquemment Posées

La leçon « Hiérarchies Result scellées » est-elle gratuite ?

Oui — le texte complet de « Hiérarchies Result scellé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 « Hiérarchies Result scellées » ?

Types de résultat personnalisés 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 3 sur 4.

Combien de temps prend la leçon « Hiérarchies Result scellé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

← Retour à Kotlin Academy