Type Classes de Cats
Functor, Monad, etc.
Type Classes de Cats es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 1 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.
¿Qué son las type classes?
Una type class es un patrón de polimorfismo ad hoc. Permite añadir comportamiento a un tipo sin modificarlo. Cats es una biblioteca de Scala que proporciona una jerarquía completa de type classes para la programación funcional.
Functor— elementos sobre los que se puede aplicarmapApplicative— combina efectos independientesMonad— secuencia efectos dependientes
Functor: map
Un Functor[F] proporciona map. Transforma el valor dentro de un contexto sin cambiar la estructura del contexto.
import cats.Functor
import cats.instances.option._
val f = Functor[Option].map(Some(2))(_ + 1)
println(f) // Some(3)Leyes de Functor
Un Functor que cumple las leyes debe obedecer dos leyes:
- Identidad:
fa.map(x => x) == fa - Composición:
fa.map(f).map(g) == fa.map(f.andThen(g))
Estas garantías permiten refactorizar cadenas de map de forma segura.
Applicative: pure y ap
Applicative[F] extiende Functor y añade pure (elevar un valor al contexto), además de la capacidad de combinar valores independientes con mapN.
import cats.Applicative
import cats.instances.option._
val lifted = Applicative[Option].pure(42)
println(lifted) // Some(42)Combinar con mapN
La sintaxis mapN combina varios valores independientes que producen efectos en uno solo, aplicando una función cuando todos están disponibles.
import cats.syntax.apply._
import cats.instances.option._
val result = (Option(1), Option(2), Option(3)).mapN(_ + _ + _)
println(result) // Some(6)Monad: flatMap
Monad[F] extiende Applicative y añade flatMap, que secuencia cálculos dependientes. Cada paso puede depender del resultado del anterior.
import cats.Monad
import cats.instances.option._
val m = Monad[Option].flatMap(Some(3))(x => Some(x * 10))
println(m) // Some(30)Leyes de Monad
Los monads deben obedecer tres leyes:
- Identidad por la izquierda:
pure(a).flatMap(f) == f(a) - Identidad por la derecha:
m.flatMap(pure) == m - Asociatividad: los flatMaps anidados se pueden reagrupar
Semigroup y Monoid
Un Semigroup[A] define combine (asociativo). Un Monoid[A] añade un elemento identidad empty. Estos elementos permiten plegar y acumular valores.
import cats.syntax.semigroup._
import cats.instances.int._
import cats.instances.string._
println(3 |+| 4) // 7
println("foo" |+| "bar") // foobarFoldable
Foldable[F] abstrae el plegado de una estructura. Combinado con Monoid, combineAll reduce una colección a un único valor.
import cats.Foldable
import cats.instances.list._
import cats.instances.int._
val total = Foldable[List].combineAll(List(1, 2, 3, 4))
println(total) // 10Traverse
Traverse[F] permite transformar cada elemento en un efecto y recopilar los resultados, convirtiendo List[F[A]] en F[List[A]].
import cats.syntax.traverse._
import cats.instances.list._
import cats.instances.option._
val r = List(1, 2, 3).traverse(x => Option(x * 2))
println(r) // Some(List(2, 4, 6))Por qué son importantes las type classes
Las type classes permiten escribir código que funciona con cualquier tipo que proporcione el comportamiento requerido. Una función restringida por Monad[F] funciona con Option, List, IO y muchos otros tipos: se escribe una vez y se reutiliza en cualquier lugar.
import cats.Monad
import cats.syntax.flatMap._
import cats.syntax.functor._
def twice[F[_]: Monad, A](fa: F[A])(f: A => A): F[A] =
fa.flatMap(a => Monad[F].pure(f(f(a))))Comprobación rápida
¿Qué type class añade flatMap para secuenciar cálculos dependientes?
Resumen
Ha explorado la jerarquía principal de type classes de Cats:
Functor—mapApplicative—pureymapNMonad—flatMapSemigroup/Monoid—combine/emptyFoldable/Traverse— plegar y recopilar efectos
A continuación conocerá el monad IO para modelar efectos de forma pura.
Preguntas frecuentes
¿La lección «Type Classes de Cats» es gratis?
Sí — el texto completo de «Type Classes de Cats» 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 «Type Classes de Cats»?
Functor, Monad, etc. 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 1 de 4.
¿Cuánto tiempo toma la lección «Type Classes de Cats»?
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
- Type Classes de Cats
- La mónada IO
- Composición de IO
- Gestión de errores en IO