Kotlin Academy · Lección

Gestión funcional de errores

Use map y recover

Gestión funcional de errores es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 4 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.

Los errores como flujos de datos

La gestión funcional de errores trata los fallos como valores que puede transformar, encadenar y de los que puede recuperarse, igual que transforma los valores correctos. El Result integrado ofrece operadores precisamente para esto.

map

map transforma un valor correcto y deja intacto un error, propagándolo sin cambios.

fun main() {
    val r = Result.success(5).map { it * 2 }
    println(r.getOrNull())
    val f = Result.failure<Int>(Exception("x")).map { it * 2 }
    println(f.getOrNull())
}

mapCatching

Si la propia transformación puede lanzar una excepción, mapCatching captura esa excepción en el resultado en lugar de dejar que escape.

fun main() {
    val r = Result.success("10").mapCatching { it.toInt() }
    println(r.getOrNull())
    val bad = Result.success("oops").mapCatching { it.toInt() }
    println(bad.isFailure)
}

recover

recover convierte un error de nuevo en un éxito calculando un valor a partir de la excepción. Un éxito pasa sin cambios.

fun main() {
    val r = Result.failure<Int>(Exception("down")).recover { 0 }
    println(r.getOrNull())
    val ok = Result.success(7).recover { 0 }
    println(ok.getOrNull())
}

recoverCatching

Cuando la lógica de recuperación también puede fallar, recoverCatching envuelve ese intento y mantiene todo como un resultado.

fun main() {
    val r = Result.failure<Int>(Exception()).recoverCatching {
        "5".toInt()
    }
    println(r.getOrNull())
}

onSuccess y onFailure

Ejecutan efectos secundarios sin cambiar el resultado y lo devuelven para seguir encadenando operaciones. Son ideales para registrar información.

fun main() {
    runCatching { "3".toInt() }
        .onSuccess { println("ok " + it) }
        .onFailure { println("fail " + it.message) }
        .also { println("done") }
}

Encadenar un pipeline

Los operadores se combinan en un pipeline claro: capturar, transformar y recuperar, todo sin bloques try/catch anidados.

fun main() {
    val result = runCatching { "21".toInt() }
        .map { it * 2 }
        .recover { -1 }
        .getOrThrow()
    println(result)
}

Finalizar con fold

Termine un pipeline con fold para convertir ambas ramas en un único valor concreto, como un mensaje para el usuario.

fun main() {
    val msg = runCatching { "x".toInt() }
        .map { it + 1 }
        .fold(
            onSuccess = { "result: " + it },
            onFailure = { "failed: " + it.message }
        )
    println(msg)
}

Mapear un tipo personalizado

Puede proporcionar a su propio tipo de resultado sellado la misma facilidad de uso escribiendo funciones de extensión como map.

sealed class Res<out T> {
    data class Ok<T>(val v: T) : Res<T>()
    data class Err(val msg: String) : Res<Nothing>()
}

fun <T, R> Res<T>.map(f: (T) -> R): Res<R> = when (this) {
    is Res.Ok -> Res.Ok(f(v))
    is Res.Err -> this
}

fun main() {
    val r = Res.Ok(4).map { it * 3 }
    println(r)
}

Por qué usar el estilo funcional

La gestión funcional de errores mantiene legible el flujo principal, mientras los errores se propagan de forma declarativa. No hay bloques try/catch dispersos y el sistema de tipos realiza un seguimiento del error de principio a fin.

Integrarlo todo

Ahora dispone de un conjunto completo de herramientas:

map / mapCatching para transformar
recover / recoverCatching para recuperarse
onSuccess / onFailure para ejecutar efectos
fold para finalizar

Comprobación rápida

Compruebe cuánto ha aprendido sobre la gestión funcional de errores.

Resumen

Ha aprendido sobre la gestión funcional de errores:

Transformar con map / mapCatching
Recuperarse con recover / recoverCatching
Observar con onSuccess / onFailure
Finalizar con fold

Con esto concluye el curso sobre Result y el modelado de errores.

Preguntas frecuentes

¿La lección «Gestión funcional de errores» es gratis?

Sí — el texto completo de «Gestión funcional de errores» 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 «Gestión funcional de errores»?

Use map y recover 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 4 de 4.

¿Cuánto tiempo toma la lección «Gestión funcional de errores»?

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