0Pricing
Scala for Backend Engineering & Functional Programming · Lección

Either para errores

Left y Right

Either para errores es una lección gratuita de Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.

¿Por qué Either?

Either representa un valor que puede ser una de dos posibilidades. Es la forma idiomática de modelar cálculos que pueden fallar proporcionando información sobre el fallo.

  • Convencionalmente, Left contiene el error.
  • Convencionalmente, Right contiene el valor correcto.

A diferencia de Option, que solo indica que falta algo, Either indica qué salió mal.

El tipo Either

Either[A, B] es un trait sellado con dos subtipos: Left[A] y Right[B].

La regla mnemotécnica es: Right es correcto (correcto), mientras que Left representa el error. Esta convención permite que map y flatMap operen automáticamente sobre el lado de éxito.

val ok: Either[String, Int] = Right(42)
val err: Either[String, Int] = Left("boom")
println(ok)
println(err)

Devolver Either desde una función

Una función que puede fallar devuelve un Either en lugar de lanzar una excepción. De este modo, quien la llama puede gestionar explícitamente ambos resultados.

object Main {
  def parseAge(s: String): Either[String, Int] =
    s.toIntOption match {
      case Some(n) if n >= 0 => Right(n)
      case Some(_)          => Left("age cannot be negative")
      case None             => Left("not a number")
    }

  def main(args: Array[String]): Unit = {
    println(parseAge("30"))
    println(parseAge("-5"))
    println(parseAge("x"))
  }
}

Coincidencia de patrones con Either

La forma más directa de consumir un Either es mediante la coincidencia de patrones. Gestione Left y Right por separado.

@main def run(): Unit = {
  val result: Either[String, Int] = Right(10)
  val msg = result match {
    case Right(value) => s"Got value: $value"
    case Left(error)  => s"Failed: $error"
  }
  println(msg)
}

fold: combinar ambos lados

fold recibe dos funciones: una para Left y otra para Right, y produce un único resultado de un tipo común.

Es una alternativa concisa a la coincidencia de patrones cuando desea obtener un valor.

@main def run(): Unit = {
  val r: Either[String, Int] = Right(7)
  val label = r.fold(
    err => s"error: $err",
    num => s"double is ${num * 2}"
  )
  println(label)
}

map opera sobre Right

map transforma el valor de Right y deja Left intacto. Este es el comportamiento con sesgo hacia Right de Either en Scala (desde la versión 2.12).

@main def run(): Unit = {
  val ok: Either[String, Int]  = Right(5)
  val no: Either[String, Int]  = Left("missing")
  println(ok.map(_ + 1))
  println(no.map(_ + 1))
}

getOrElse y valores predeterminados

getOrElse extrae el valor de Right o devuelve un valor alternativo cuando el Either es un Left.

@main def run(): Unit = {
  val ok: Either[String, Int] = Right(99)
  val no: Either[String, Int] = Left("oops")
  println(ok.getOrElse(0))
  println(no.getOrElse(0))
}

swap: invertir los lados

swap intercambia Left y Right. Resulta útil cuando desea operar sobre el lado del error mediante métodos con sesgo hacia Right.

@main def run(): Unit = {
  val err: Either[String, Int] = Left("bad input")
  val swapped = err.swap.map(_.toUpperCase)
  println(swapped)
}

isLeft e isRight

Estas comprobaciones booleanas rápidas le permiten ramificar sin realizar una coincidencia de patrones completa.

  • isRight devuelve true cuando el resultado es satisfactorio.
  • isLeft devuelve true cuando hay un error.
@main def run(): Unit = {
  val r: Either[String, Int] = Right(1)
  println(r.isRight)
  println(r.isLeft)
}

toOption: descartar el error

Cuando ya no le importa por qué falló algo, toOption convierte un Either en un Option: Right(x) se convierte en Some(x) y Left(_) en None.

@main def run(): Unit = {
  val ok: Either[String, Int] = Right(3)
  val no: Either[String, Int] = Left("err")
  println(ok.toOption)
  println(no.toOption)
}

Un ejemplo de validación

Unámoslo todo: valide un nombre de usuario y devuelva un error tipado si falla.

object Main {
  def validate(name: String): Either[String, String] =
    if (name.isEmpty) Left("empty name")
    else if (name.length > 10) Left("name too long")
    else Right(name)

  def main(args: Array[String]): Unit = {
    println(validate("alice"))
    println(validate(""))
    println(validate("verylongusername"))
  }
}

Comprobación rápida

Compruebe su comprensión de las convenciones de Either.

Resumen

Ha aprendido a modelar errores con Either:

  • Right = éxito, Left = error (con sesgo hacia Right).
  • Consúmalos mediante coincidencia de patrones o fold.
  • Transforme el resultado satisfactorio con map y proporcione valores predeterminados con getOrElse.
  • Invierta los lados con swap y convierta con toOption.

A continuación, gestionará excepciones con Try.

Preguntas frecuentes

¿La lección «Either para errores» es gratis?

Sí — el texto completo de «Either para 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 Scala for Backend Engineering & Functional Programming, actualiza a CoddyKit PRO. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.

¿Qué aprenderé en «Either para errores»?

Left y Right Practicas Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming?

No se requiere experiencia previa. Scala for Backend Engineering & Functional Programming 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 para 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 Scala for Backend Engineering & Functional Programming?

Sí. Cada lección de Scala for Backend Engineering & Functional Programming 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 para errores
  2. Try, Success, Failure
  3. Composición de Either
  4. Conversión entre tipos
← Volver a Scala for Backend Engineering & Functional Programming