0Pricing
Kotlin Academy · Lección

Either<L, R>: gestión de errores tipada sin excepciones

Utilice Either para representar el éxito y el fracaso sin lanzar excepciones

Either<L, R>: gestión de errores tipada sin excepciones es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 1 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.

El problema de usar excepciones para la lógica de negocio

Las excepciones están diseñadas para fallos inesperados (puntero nulo, error de E/S). Usarlas para indicar fallos de negocio esperados (fallo de validación, "no encontrado") hace que el flujo de control sea invisible, obliga a usar try/catch en cada punto de llamada y oculta los errores en las firmas de las funciones.

¿Qué es Either<L, R>?

Either es un tipo suma con dos casos: convencionalmente, Left(value: L) contiene el error y Right(value: R) contiene el valor correcto. Una función que devuelve Either hace explícita en su firma la posibilidad de fallo.

Either de Arrow

Añada Arrow a su proyecto para obtener Either y todo su ecosistema de operadores:

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

Devolver Either desde una función

Devuelva value.right() cuando la operación sea correcta y error.left() cuando falle. La persona que realiza la llamada debe gestionar ambas ramas:

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

Consumir Either con fold

Use fold(ifLeft, ifRight) para gestionar ambos casos en una sola expresión:

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

Transformar el valor Right con map

map { } transforma el valor de Right sin modificar un Left. Esto convierte a Either en un functor: puede encadenar transformaciones de forma segura:

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

Encadenamiento con flatMap

flatMap { } encadena cálculos que devuelven Either. Si algún paso devuelve Left, la cadena se detiene y el error se propaga sin ejecutar los pasos posteriores:

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 para envolver excepciones

Either.catch { } ejecuta un bloque y envuelve cualquier excepción como un Left. Úselo en el límite entre el código heredado que lanza excepciones y su dominio basado en Either:

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

Recuperación con getOrElse y orElse

getOrElse { default } extrae el valor de Right o devuelve un valor predeterminado. orElse { alternativeEither } reemplaza un Left por otro cálculo:

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

Coincidencia de patrones con when

Use when sobre una clase sellada similar a Either o sobre el propio Either con is Either.Left / Either.Right para gestionar todos los casos de forma exhaustiva:

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

Either en las capas de servicio

Devuelva Either desde las funciones del repositorio y del servicio. Asócielo a respuestas HTTP en el nivel de las rutas de Ktor, manteniendo la lógica de negocio libre de aspectos del 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) }
    )
}

Comprobación rápida

¿Qué hace flatMap { } sobre un valor Either.Left?

Repaso: Either<L, R>

Puntos clave:

  • Either hace explícita la ruta de fallo en la firma de la función
  • Right = operación correcta; Left = fallo (por convención)
  • map { } — transforma el valor correcto; flatMap { } — encadena cálculos que pueden fallar
  • fold(ifLeft, ifRight) — consume ambos casos en una sola expresión
  • Either.catch { } — envuelve código que lanza excepciones en los límites

Preguntas frecuentes

¿La lección «Either<L, R>: gestión de errores tipada sin excepciones» es gratis?

Sí — el texto completo de «Either<L, R>: gestión de errores tipada sin excepciones» 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 «Either<L, R>: gestión de errores tipada sin excepciones»?

Utilice Either para representar el éxito y el fracaso sin lanzar excepciones 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 1 de 4.

¿Cuánto tiempo toma la lección «Either<L, R>: gestión de errores tipada sin excepciones»?

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

  1. Either : gestión de errores tipada sin excepciones
  2. DSL Raise de Arrow: composición de errores tipados
  3. Option y Nullable: cuándo utilizar cada uno
  4. Modelado funcional de dominios con los tipos principales de Arrow
← Volver a Kotlin Academy