Tratamento de erros em IO
handleError.
Tratamento de erros em IO é 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.
Falhas como valores
No Cats Effect, um IO pode falhar. A falha faz parte do valor, portanto você pode inspecioná-la e se recuperar dela sem um try/catch desestruturado.
Lançando falhas
Use IO.raiseError para criar explicitamente um IO com falha e uma exceção escolhida.
import cats.effect.IO
val failed: IO[Int] =
IO.raiseError(new RuntimeException("boom"))handleError
handleError recupera um IO com falha fornecendo um valor alternativo calculado a partir da falha. O resultado é um IO que não pode falhar neste ponto.
import cats.effect.IO
val safe: IO[Int] =
IO.raiseError[Int](new RuntimeException("x"))
.handleError(_ => -1)handleErrorWith
handleErrorWith recupera usando outro IO, portanto o valor alternativo também pode produzir efeitos (por exemplo, registrar informações, tentar novamente ou retornar um valor padrão).
import cats.effect.IO
val recovered: IO[Int] =
IO(throw new RuntimeException("fail"))
.handleErrorWith(e => IO.println(s"caught: ${e.getMessage}").as(0))attempt
attempt converte um IO[A] em IO[Either[Throwable, A]], materializando a falha no valor para que você possa fazer correspondência de padrões com ela.
import cats.effect.IO
val e: IO[Either[Throwable, Int]] =
IO.raiseError[Int](new RuntimeException("oops")).attemptCorrespondência de padrões com attempt
Depois de attempt, você pode escolher entre sucesso e falha usando um flatMap normal sobre o Either.
import cats.effect.IO
val prog: IO[Unit] = IO(10 / 2).attempt.flatMap {
case Right(v) => IO.println(s"ok: $v")
case Left(e) => IO.println(s"err: ${e.getMessage}")
}redeem
redeem trata os dois casos em uma única chamada: uma função para a falha e outra para o sucesso, ambas retornando um valor simples.
import cats.effect.IO
val label: IO[String] =
IO(42).redeem(e => s"failed: $e", v => s"value: $v")redeemWith
redeemWith é semelhante a redeem, mas cada caso retorna um IO, permitindo o tratamento com efeitos tanto do sucesso quanto da falha.
import cats.effect.IO
val prog: IO[Unit] = IO(42).redeemWith(
e => IO.println(s"err: $e"),
v => IO.println(s"got: $v")
)Limpeza com guarantee
guarantee executa um finalizador independentemente de o efeito ter sucesso ou falhar — perfeito para liberar recursos ou registrar a conclusão.
import cats.effect.IO
val prog: IO[Int] =
IO(compute()).guarantee(IO.println("done"))
def compute(): Int = 7Tentando novamente após uma falha
Você pode criar uma nova tentativa simples recuperando recursivamente com handleErrorWith e decrementando um contador até ele chegar a zero.
import cats.effect.IO
def retry[A](io: IO[A], n: Int): IO[A] =
if (n <= 0) io
else io.handleErrorWith(_ => retry(io, n - 1))try/catch em Scala simples
Compare com o tratamento clássico e imediato de falhas em Scala simples. Os combinadores de IO oferecem a mesma segurança, mas como valores puros e componíveis.
object Main {
def main(args: Array[String]): Unit = {
val result = try { 10 / 0 } catch { case _: ArithmeticException => -1 }
println(s"result: $result")
}
}Verificação rápida
Qual método transforma um IO[A] em IO[Either[Throwable, A]]?
Recapitulação
Você tratou falhas em IO com:
raiseErrorpara falhar explicitamentehandleError/handleErrorWithpara recuperarattemptpara materializarEitherredeem/redeemWithpara os dois casosguaranteepara limpeza
Você concluiu o curso de Cats e IO.
Aprenda Scala com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 39
- Aulas
- 143
Perguntas Frequentes
A aula “Tratamento de erros em IO” é grátis?
Sim — o texto completo de “Tratamento de erros em IO” é 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 “Tratamento de erros em IO”?
handleError. 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 “Tratamento de erros em IO”?
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
- Classes de tipos do Cats
- A mônada IO
- Compondo IO
- Tratamento de erros em IO