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

Conversión entre tipos

Option, Either, Try

Conversión entre tipos es una lección gratuita de Scala for Backend Engineering & Functional Programming 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 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.

Tres modelos de error

Scala ofrece tres tipos complementarios para representar la ausencia y los fallos:

  • Option — presencia o ausencia (sin indicar el motivo).
  • Either — éxito o un error tipado.
  • Try — éxito o una excepción lanzada.

Saber convertir entre ellos le permite adaptar una API a otra.

De Option a Either

toRight convierte un Option en un Either, proporcionando un error Left para el caso None. toLeft realiza la conversión inversa.

@main def run(): Unit = {
  val some: Option[Int] = Some(5)
  val none: Option[Int] = None
  println(some.toRight("missing"))
  println(none.toRight("missing"))
}

De Either a Option

toOption descarta el error: Right(x) se convierte en Some(x) y Left(_) en None. Úselo cuando el motivo del fallo ya no sea relevante.

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

De Try a Option

Try.toOption convierte un Success en Some y un Failure en None, descartando la excepción.

import scala.util.Try

@main def run(): Unit = {
  println(Try("7".toInt).toOption)
  println(Try("x".toInt).toOption)
}

De Try a Either

Try.toEither produce un Either[Throwable, T]: Success se convierte en Right y Failure en Left(throwable). Así se conserva la excepción como un left tipado.

import scala.util.Try

@main def run(): Unit = {
  val ok = Try("7".toInt).toEither
  val no = Try("x".toInt).toEither
  println(ok)
  println(no.left.map(_.getMessage))
}

De Either a Try

No existe una conversión integrada directa de Either a Try para un error simple, pero puede crearla: envuelva un Right en Success y un Left en un Failure que contenga una excepción.

import scala.util.{Try, Success, Failure}

object Main {
  def toTry(e: Either[String, Int]): Try[Int] = e match {
    case Right(v) => Success(v)
    case Left(m)  => Failure(new RuntimeException(m))
  }

  def main(args: Array[String]): Unit = {
    println(toTry(Right(1)))
    println(toTry(Left("bad")))
  }
}

De Option a Try

Convierta un Option en un Try eligiendo una excepción para el caso vacío. Resulta útil cuando una API espera un Try.

import scala.util.{Try, Success, Failure}

object Main {
  def toTry[A](o: Option[A]): Try[A] = o match {
    case Some(v) => Success(v)
    case None    => Failure(new NoSuchElementException("empty"))
  }

  def main(args: Array[String]): Unit = {
    println(toTry(Some(9)))
    println(toTry(None))
  }
}

Normalizar una canalización

Mezclar tipos provoca dificultades. Un enfoque habitual consiste en convertir todo a Either con un tipo de error uniforme desde el principio y, después, componer libremente.

import scala.util.Try

object Main {
  def parse(s: String): Either[String, Int] =
    Try(s.toInt).toEither.left.map(_ => s"invalid: $s")

  def lookup(n: Int): Either[String, String] =
    Map(1 -> "one", 2 -> "two").get(n).toRight(s"no entry for $n")

  def main(args: Array[String]): Unit = {
    val result = for {
      n <- parse("2")
      w <- lookup(n)
    } yield w
    println(result)
  }
}

getOrElse entre tipos

Los tres tipos admiten getOrElse para extraer un valor o proporcionar uno predeterminado. A menudo, este es el paso final para salir del ámbito de la gestión de errores.

import scala.util.Try

@main def run(): Unit = {
  val a = Some(1).getOrElse(0)
  val b = (Right(2): Either[String, Int]).getOrElse(0)
  val c = Try("x".toInt).getOrElse(0)
  println(s"$a $b $c")
}

Elegir el tipo adecuado

Recomendaciones:

  • Use Option cuando la ausencia no necesite explicación.
  • Use Either cuando desee un valor de error específico del dominio.
  • Use Try en los límites que interactúan con código Java o de bibliotecas que lanza excepciones.

Ejemplo de principio a fin

Leer código que lanza excepciones mediante Try, convertirlo en Either para representar errores del dominio y, finalmente, convertirlo en Option para quien solo necesita saber si existe un valor.

import scala.util.Try

object Main {
  def safeDiv(a: Int, b: Int): Option[Int] =
    Try(a / b).toEither.left.map(_ => "math error").toOption

  def main(args: Array[String]): Unit = {
    println(safeDiv(10, 2))
    println(safeDiv(10, 0))
  }
}

Comprobación rápida

Compruebe sus conocimientos sobre conversiones.

Resumen

Ha aprendido a convertir entre Option, Either y Try:

  • Option.toRight → Either; Either.toOption → Option.
  • Try.toOption y Try.toEither conectan las excepciones con los valores.
  • Normalice pronto una canalización a un único tipo de error.
  • Elija el tipo que corresponda al nivel de detalle del error que necesite.

Preguntas frecuentes

¿La lección «Conversión entre tipos» es gratis?

Sí — el texto completo de «Conversión entre tipos» 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 «Conversión entre tipos»?

Option, Either, Try 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 4 de 4.

¿Cuánto tiempo toma la lección «Conversión entre tipos»?

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