Scala for Backend Engineering & Functional Programming · Aula

Convertendo entre tipos

Option, Either, Try.

Convertendo entre tipos é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

Três modelos de erro

O Scala oferece três tipos complementares para ausência e falha:

Option — presença ou ausência (sem motivo).
Either — sucesso ou um erro tipado.
Try — sucesso ou uma exceção lançada.

Saber convertê-los entre si permite adaptar uma API a outra.

De Option para Either

toRight converte um Option em um Either, fornecendo um erro Left para o caso None. toLeft faz o mapeamento inverso.

@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 para Option

toOption descarta o erro: Right(x) se torna Some(x) e Left(_) se torna None. Use isso quando o motivo da falha já não importar.

@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 para Option

Try.toOption transforma um Success em Some e um Failure em None, ignorando a exceção.

import scala.util.Try

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

De Try para Either

Try.toEither produz um Either[Throwable, T]: Success se torna Right, e Failure se torna Left(throwable). Assim, a exceção é preservada como um 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 para Try

Não há uma conversão integrada direta de Either para Try com um erro simples, mas você pode criar uma: envolva um Right em Success e um Left em um Failure que contenha uma exceção.

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 para Try

Converta um Option em um Try escolhendo uma exceção para o caso vazio. Isso é útil quando uma API espera um 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))
  }
}

Normalizando um fluxo

Misturar tipos causa atrito. Uma abordagem comum é converter tudo para Either, usando antecipadamente um tipo de erro uniforme, e então compor livremente.

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

Os três tipos oferecem suporte a getOrElse para extrair um valor ou fornecer um valor padrão. Essa costuma ser a etapa final, que encerra o tratamento de erros.

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

Escolhendo o tipo adequado

Diretrizes:

Use Option quando a ausência não precisar de explicação.
Use Either quando quiser um valor de erro específico do domínio.
Use Try nas fronteiras com código de bibliotecas ou Java que lança exceções.

Exemplo completo

Leia código que lança exceções usando Try, converta-o em Either para representar erros do domínio e, por fim, em Option para um chamador que só se importa com a presença.

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

Verificação rápida

Teste seus conhecimentos sobre conversões.

Recapitulação

Você aprendeu a converter entre Option, Either e Try:

Option.toRight → Either; Either.toOption → Option.
Try.toOption e Try.toEither fazem a ponte entre exceções e valores.
Normalize o pipeline para um único tipo de erro desde o início.
Escolha o tipo que corresponda ao nível de detalhe dos erros de que você precisa.

Perguntas Frequentes

A aula “Convertendo entre tipos” é grátis?

Sim — o texto completo de “Convertendo entre tipos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

O que vou aprender em “Convertendo entre tipos”?

Option, Either, Try. Você pratica Scala for Backend Engineering & Functional Programming com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Scala for Backend Engineering & Functional Programming?

Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Convertendo entre tipos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Scala for Backend Engineering & Functional Programming?

Sim. Cada aula de Scala for Backend Engineering & Functional Programming inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Scala for Backend Engineering & Functional Programming