0Pricing
Scala for Backend Engineering & Functional Programming · Aula

Compondo IO

Sequenciamento de efeitos.

Compondo IO é 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.

Sequenciamento com flatMap

Como IO é uma mônada, você compõe efeitos com flatMap. Cada etapa é executada na ordem, e uma etapa posterior pode usar o resultado de uma etapa anterior.

import cats.effect.IO

val program: IO[Unit] =
  IO("Alice").flatMap(name => IO.println(s"Hello, $name"))

Compreensão for

Uma compreensão for é traduzida para flatMap/map e se parece com um roteiro imperativo, mantendo-se pura.

import cats.effect.IO

val prog: IO[Unit] = for {
  _    <- IO.println("What is your name?")
  name <- IO("Bob")
  _    <- IO.println(s"Hi $name")
} yield ()

A ordem é preservada

Os efeitos em uma compreensão for são executados de cima para baixo quando o programa é executado. A estrutura do código reflete a ordem de execução.

Combinando efeitos independentes

Quando dois efeitos não dependem um do outro, use mapN ou (a, b).tupled para combiná-los. Por padrão, eles ainda são executados sequencialmente, mas a independência fica expressa.

import cats.effect.IO
import cats.syntax.apply._

val combined: IO[Int] = (IO(2), IO(3)).mapN(_ + _)

Executando efeitos em paralelo

Use parMapN (de cats.syntax.parallel) para executar efeitos independentes simultaneamente em fibras separadas e combinar seus resultados.

import cats.effect.IO
import cats.syntax.parallel._

val par: IO[Int] = (IO(2), IO(3)).parMapN(_ + _)

Descartando resultados

Use *> para executar um efeito e manter o segundo resultado, ou <* para manter o primeiro. void descarta o resultado por completo, produzindo IO[Unit].

import cats.effect.IO

val r1: IO[Int]  = IO.println("log") *> IO(42)
val r2: IO[Unit] = IO(99).void

Repetindo efeitos

replicateA(n) executa um efeito n vezes e coleta os resultados em uma lista. foreverM repete indefinidamente.

import cats.effect.IO

val three: IO[List[Unit]] = IO.println("tick").replicateA(3)

Percorrendo uma lista

Transforme um List[A] em um efeito sobre um List[B] com traverse. Cada elemento produz um IO, e os resultados são reunidos.

import cats.effect.IO
import cats.syntax.traverse._

val names = List("a", "b", "c")
val prog: IO[List[Unit]] = names.traverse(n => IO.println(n))

parTraverse

parTraverse é a versão paralela de traverse — o efeito de cada elemento é executado em sua própria fibra, o que é ideal para E/S concorrente, como buscar muitas URLs.

import cats.effect.IO
import cats.syntax.parallel._

val ids = List(1, 2, 3)
val prog: IO[List[Int]] = ids.parTraverse(id => IO(id * 10))

Um programa composto

Este programa lê um valor, dobra-o e imprime o resultado — tudo composto a partir de pequenas etapas IO em uma única descrição.

import cats.effect.{IO, IOApp}

object Doubler extends IOApp.Simple {
  def run: IO[Unit] = for {
    n <- IO(21)
    d  = n * 2
    _ <- IO.println(s"Doubled: $d")
  } yield ()
}

Sequenciamento em Scala simples

Para comparação, este é um resultado sequencial no console em Scala simples — imediato e impuro, ao contrário da versão IO adiada acima.

object Main {
  def main(args: Array[String]): Unit = {
    val n = 21
    val d = n * 2
    println(s"Doubled: $d")
  }
}

Verificação rápida

Qual método executa dois efeitos independentes simultaneamente e combina seus resultados?

Recapitulação

Você compôs programas IO com:

  • flatMap e for para sequenciamento
  • mapN / parMapN para efeitos independentes
  • *>, <*, void para combinar ou descartar
  • traverse / parTraverse para coleções

A seguir: tratamento de falhas dentro de IO.

Perguntas Frequentes

A aula “Compondo IO” é grátis?

Sim — o texto completo de “Compondo 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 “Compondo IO”?

Sequenciamento de efeitos. 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 “Compondo 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

  1. Classes de tipos do Cats
  2. A mônada IO
  3. Compondo IO
  4. Tratamento de erros em IO
← Voltar para Scala for Backend Engineering & Functional Programming