Kotlin Academy · Lección

Jerarquías selladas de Result

Tipos Result personalizados

Lección 3 de 413 pasos

Jerarquías selladas de Result es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.

Más allá del Result integrado

El Result de Kotlin solo contiene una excepción cuando se produce un error. A menudo necesitará información de error más completa y tipada. Una jerarquía de clases selladas permite modelar exactamente los resultados posibles de su dominio.

Un resultado sellado

Defina un tipo sellado con subclases de éxito y de error. El compilador conoce todos los casos, lo que permite una gestión exhaustiva.

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

when exhaustivo

Como el tipo es sellado, un when sobre él no necesita else, y el compilador obliga a gestionar todos los casos.

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 de error tipadas

Modele distintos tipos de fallo como subclases independientes, cada una con los datos relevantes. Esto es mejor que una única excepción opaca.

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

Gestionar cada variante

Un when puede reaccionar específicamente a cada tipo de error, con todos los datos disponibles para cada rama.

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

El truco de Nothing

Las variantes de error que no contienen un valor de éxito usan Outcome<Nothing>. Como Nothing es un subtipo de todos los tipos y el genérico es out, un error encaja en cualquier 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))
}

Object para casos sin estado

Si una variante de error no contiene datos, declárela como un singleton object en lugar de una clase.

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

Devolver la jerarquía

Las funciones devuelven el tipo sellado; quienes las llaman deben contemplar todos los resultados posibles, lo que elimina las rutas de error olvidadas.

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

Sealed frente a Result integrado

Use el Result integrado para capturas rápidas basadas en excepciones. Use una jerarquía sellada personalizada cuando necesite varios casos de error tipados con datos específicos del dominio y una gestión exhaustiva.

Diseñar la jerarquía

Un buen diseño de resultados sellados incluye:

Una variante de éxito que contenga la carga útil
Una subclase por cada modo de fallo significativo
Varianza out T con Nothing para los casos que solo representan errores

El compilador como red de seguridad

La mayor ventaja es que, cuando añada más adelante una variante nueva, cada when no exhaustivo se convertirá en un error de compilación que le señalará cada lugar que debe gestionarla. Los errores no pueden pasar desapercibidos.

Comprobación rápida

Compruebe su comprensión de las jerarquías de resultados selladas.

Responde en la lección interactiva

Resumen

Ha creado jerarquías de resultados selladas:

Éxito más variantes de error tipadas
when exhaustivo sin else
out T y Nothing para los casos que solo representan errores
Gestión de las nuevas variantes impuesta por el compilador

A continuación: gestión funcional de errores con map y recover.

Gratis para empezar

Aprende Kotlin con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos: 51
Lecciones: 203

Empezar a aprender gratis Ver el curso completo

Preguntas frecuentes

¿La lección «Jerarquías selladas de Result» es gratis?

Sí — el texto completo de «Jerarquías selladas de Result» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Jerarquías selladas de Result»?

Tipos Result personalizados Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Kotlin Academy?

No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Jerarquías selladas de Result»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?

Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Kotlin Academy