0Pricing
Scala for Backend Engineering & Functional Programming · Lección

Composición de IO

Secuenciación de efectos

Composición de IO es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Scala for Backend Engineering & Functional Programming, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.

Secuenciación con flatMap

Como IO es una mónada, los efectos se componen con flatMap. Cada paso se ejecuta en orden y un paso posterior puede usar el resultado de uno anterior.

import cats.effect.IO

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

for-comprehension

Una for-comprehension se desazucara a flatMap/map y se lee como un script imperativo, aunque mantiene la pureza.

import cats.effect.IO

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

Se conserva el orden

Los efectos de una for-comprehension se ejecutan de arriba abajo cuando se ejecuta el programa. La estructura del código refleja el orden de ejecución.

Combinación de efectos independientes

Cuando dos efectos no dependen entre sí, use mapN o (a, b).tupled para combinarlos. De forma predeterminada, siguen ejecutándose secuencialmente, pero expresan su independencia.

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

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

Ejecución de efectos en paralelo

Use parMapN (de cats.syntax.parallel) para ejecutar efectos independientes de forma concurrente en fibras separadas y combinar sus resultados.

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

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

Descartar resultados

Use *> para ejecutar un efecto y conservar el segundo resultado, o <* para conservar el primero. void descarta completamente el resultado y produce IO[Unit].

import cats.effect.IO

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

Repetición de efectos

replicateA(n) ejecuta un efecto n veces y recopila los resultados en una lista. foreverM lo repite indefinidamente.

import cats.effect.IO

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

Recorrido de una List

Convierta una List[A] en un efecto sobre una List[B] mediante traverse. Cada elemento produce un IO y los resultados se recopilan.

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 es la versión paralela de traverse: el efecto de cada elemento se ejecuta en su propia fibra, lo que resulta ideal para E/S concurrentes, como obtener muchas URL.

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

Un programa compuesto

Este programa lee un valor, lo duplica e imprime el resultado, todo ello compuesto a partir de pequeños pasos IO en una única descripción.

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

Secuenciación en Scala convencional

Como comparación, aquí se muestra una salida secuencial de consola en Scala convencional: es inmediata e impura, a diferencia de la versión diferida con IO anterior.

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

Comprobación rápida

¿Qué método ejecuta de forma concurrente dos efectos independientes y combina sus resultados?

Resumen

Ha compuesto programas IO con:

  • flatMap y for para la secuenciación
  • mapN / parMapN para efectos independientes
  • *>, <*, void para combinar o descartar
  • traverse / parTraverse para colecciones

A continuación: gestión de errores dentro de IO.

Preguntas frecuentes

¿La lección «Composición de IO» es gratis?

Sí — el texto completo de «Composición de IO» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Scala for Backend Engineering & Functional Programming, actualiza a CoddyKit PRO. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.

¿Qué aprenderé en «Composición de IO»?

Secuenciación de efectos Practicas Scala for Backend Engineering & Functional Programming con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Scala for Backend Engineering & Functional Programming?

No se requiere experiencia previa. Scala for Backend Engineering & Functional Programming en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Composición de IO»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Scala for Backend Engineering & Functional Programming?

Sí. Cada lección de Scala for Backend Engineering & Functional Programming incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Type Classes de Cats
  2. La mónada IO
  3. Composición de IO
  4. Gestión de errores en IO
← Volver a Scala for Backend Engineering & Functional Programming