Canais de erros e dependências
Erros tipados e ambiente.
Canais de erros e dependências é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 3 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.
Dois canais poderosos
Além do valor de sucesso, ZIO[R, E, A] acompanha um canal de erro tipado E e um canal de dependência R. Ambos ficam visíveis no tipo, tornando falhas e requisitos explícitos em tempo de compilação.
Erros tipados
Modele as falhas do domínio como uma hierarquia selada e coloque-a em E. Assim, o compilador força você a tratar exatamente esses casos.
import zio._
sealed trait AppError
case object NotFound extends AppError
case object Forbidden extends AppError
val lookup: IO[AppError, String] = ZIO.fail(NotFound)Recuperação com catchAll
catchAll trata todos os erros em E fornecendo um novo efeito. Depois dele, o canal de erros pode se tornar Nothing se for totalmente tratado.
import zio._
val safe: UIO[String] =
ZIO.fail("boom").catchAll(e => ZIO.succeed(s"recovered: $e"))catchSome e orElse
catchSome recupera apenas os erros correspondentes. orElse recorre a outro efeito quando ocorre qualquer falha.
import zio._
val prog = ZIO.fail("x").orElse(ZIO.succeed("fallback"))Either e fold
either transforma ZIO[R, E, A] em ZIO[R, Nothing, Either[E, A]]. fold trata o erro e o sucesso em um único valor.
import zio._
val label: UIO[String] =
ZIO.fail(404).fold(e => s"err $e", v => s"ok $v")Defeitos versus falhas
O ZIO distingue falhas (tipadas, esperadas, em E) de defeitos (exceções inesperadas). ZIO.die causa um defeito; os defeitos não fazem parte do tipo E e representam erros no código.
O ambiente R
O canal R declara os serviços de que um efeito precisa. Acesse um serviço com ZIO.service; o requisito permanece em R até ser fornecido.
import zio._
trait Logger { def log(s: String): UIO[Unit] }
val prog: ZIO[Logger, Nothing, Unit] =
ZIO.serviceWithZIO[Logger](_.log("hello"))Definindo um serviço
Um serviço é um trait acompanhado de um ZLayer que o constrói. As camadas descrevem como construir dependências e também podem depender de outras.
import zio._
case class ConsoleLogger() extends Logger {
def log(s: String): UIO[Unit] = ZIO.succeed(println(s))
}
object ConsoleLogger {
val layer: ULayer[Logger] = ZLayer.succeed(ConsoleLogger())
}
trait Logger { def log(s: String): UIO[Unit] }Fornecendo dependências
provide (ou provideLayer) satisfaz o requisito R, transformando ZIO[Logger, E, A] em ZIO[Any, E, A], pronto para ser executado.
import zio._
val runnable: UIO[Unit] =
ZIO.serviceWithZIO[Logger](_.log("hi"))
.provide(ConsoleLogger.layer)
trait Logger { def log(s: String): UIO[Unit] }
object ConsoleLogger { val layer: ULayer[Logger] = ??? }Compondo camadas
As camadas são compostas horizontalmente com ++ (combinar) e verticalmente com >>> (fornecer a saída de uma camada como entrada de outra), construindo um grafo completo de dependências.
import zio._
// val appLayer = configLayer ++ (dbLayer >>> repoLayer)Referência em Scala simples
Para comparação, um programa Scala autocontido com tratamento manual de erros. ZIO codifica o mesmo erro no tipo e injeta dependências por meio de camadas.
object Main {
def main(args: Array[String]): Unit = {
val result: Either[String, Int] = Left("NotFound")
val msg = result.fold(e => s"err $e", v => s"ok $v")
println(msg)
}
}Verificação rápida
O que o método provide faz com um ZIO[Logger, E, A]?
Recapitulação
Você trabalhou com os dois canais adicionais:
- Erros:
Etipado,catchAll,orElse,fold, defeitos versus falhas - Dependências:
R, serviços,ZLayer,provide, composição de camadas
A seguir: executando aplicações ZIO.
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 “Canais de erros e dependências” é grátis?
Sim — o texto completo de “Canais de erros e dependências” é 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 “Canais de erros e dependências”?
Erros tipados e ambiente. 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 3 de 4.
Quanto tempo leva a aula “Canais de erros e dependências”?
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
- O efeito ZIO
- Compondo ZIO
- Canais de erros e dependências
- Executando aplicações ZIO