Scala for Backend Engineering & Functional Programming · Aula

A mônada IO

Efeitos puros.

A mônada IO é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 2 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.

O que é IO?

IO[A] do Cats Effect é uma descrição de uma computação que, quando executada, pode realizar efeitos colaterais e produzir um valor do tipo A. É um valor puro — nada acontece até que você a execute.

Adiar efeitos colaterais

Envolva um efeito colateral com IO(...) ou IO.delay(...). O corpo não é executado quando o IO é criado — somente quando ele é executado.

import cats.effect.IO

val program: IO[Unit] = IO(println("Hello, IO!"))
// Nothing printed yet — program is just a description

Transparência referencial

Como IO é preguiçoso, você pode substituir um valor IO pela sua definição sem alterar o comportamento. Essa transparência referencial facilita a análise e a refatoração de código com efeitos.

Valores puros

Use IO.pure para elevar um valor já calculado. Não coloque efeitos colaterais dentro de pure — ele é avaliado imediatamente. Use IO.delay ou IO(...) para efeitos.

import cats.effect.IO

val p: IO[Int] = IO.pure(42)
// 42 is computed already; pure just wraps it

map e as

map transforma o resultado de um IO. as o substitui por uma constante. Nenhum dos dois executa o efeito — eles constroem uma descrição maior.

import cats.effect.IO

val len: IO[Int] = IO("hello").map(_.length)
val done: IO[String] = IO(println("ran")).as("done")

Executando com IOApp

Para executar um programa IO, estenda IOApp e implemente run, retornando um IO[ExitCode]. O ambiente de execução o avalia em um agendador baseado em fibras.

import cats.effect.{IO, IOApp, ExitCode}

object Main extends IOApp {
  def run(args: List[String]): IO[ExitCode] =
    IO(println("Running!")).as(ExitCode.Success)
}

IOApp.Simple

Para programas sem argumentos ou códigos de saída personalizados, estenda IOApp.Simple e forneça um run: IO[Unit].

import cats.effect.{IO, IOApp}

object Hello extends IOApp.Simple {
  def run: IO[Unit] = IO.println("Hello, world!")
}

IO.println

O Cats Effect fornece IO.println como uma forma conveniente de imprimir com efeito. Ele retorna IO[Unit] e só imprime quando é executado.

import cats.effect.IO

val greet: IO[Unit] = IO.println("effectful output")

Capturando exceções

Se o efeito envolvido lançar uma exceção, a falha será capturada dentro do IO em vez de escapar. O IO se torna um valor com falha que você poderá tratar posteriormente.

import cats.effect.IO

val boom: IO[Int] = IO(throw new RuntimeException("fail"))
// Creating boom does NOT throw; running it would

Comparação com Scala simples

Sem um tipo de efeito, os efeitos colaterais são executados imediatamente e são difíceis de compor. IO os adia; assim, um programa Scala autocontido imprime imediatamente, enquanto o IO adiaria a impressão.

object Main {
  def main(args: Array[String]): Unit = {
    val eager = println("runs now") // executed immediately
    println("second line")
  }
}

Por que usar IO?

IO oferece:

Pureza — efeitos são valores
Componibilidade — construa programas a partir de partes pequenas
Segurança — falhas e recursos são rastreados
Concorrência — fibras leves

Verificação rápida

Quando o efeito colateral dentro de IO(println("hi")) é realmente executado?

Recapitulação

A mônada IO modela efeitos como valores puros e preguiçosos:

IO(...) / IO.delay adiam efeitos
IO.pure envolve valores calculados
IOApp / IOApp.Simple executam programas
Exceções são capturadas, não lançadas imediatamente

A seguir: composição de várias ações IO.

Perguntas Frequentes

A aula “A mônada IO” é grátis?

Sim — o texto completo de “A mônada 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 “A mônada IO”?

Efeitos puros. 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 2 de 4.

Quanto tempo leva a aula “A mônada 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

← Voltar para Scala for Backend Engineering & Functional Programming