Scala for Backend Engineering & Functional Programming · Aula

Classes de tipos do Cats

Functor, Monad etc.

Classes de tipos do Cats é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 1 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 são classes de tipos?

Uma classe de tipos é um padrão para polimorfismo ad hoc. Ela permite adicionar comportamento a um tipo sem modificá-lo. Cats é uma biblioteca Scala que fornece uma hierarquia rica de classes de tipos para programação funcional.

Functor — elementos sobre os quais você pode aplicar map
Applicative — combina efeitos independentes
Monad — encadeia efeitos dependentes

Functor: map

Um Functor[F] fornece map. Ele transforma o valor dentro de um contexto sem alterar a estrutura desse contexto.

import cats.Functor
import cats.instances.option._

val f = Functor[Option].map(Some(2))(_ + 1)
println(f) // Some(3)

Leis do Functor

Um Functor que respeita as leis deve obedecer a duas leis:

Identidade: fa.map(x => x) == fa
Composição: fa.map(f).map(g) == fa.map(f.andThen(g))

Essas garantias permitem refatorar cadeias de map com segurança.

Applicative: pure e ap

Applicative[F] estende Functor e adiciona pure (eleva um valor para o contexto) e a capacidade de combinar valores independentes com mapN.

import cats.Applicative
import cats.instances.option._

val lifted = Applicative[Option].pure(42)
println(lifted) // Some(42)

Combinando com mapN

A sintaxe mapN combina vários valores independentes que produzem efeitos em um só, aplicando uma função quando todos estão presentes.

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] estende Applicative e adiciona flatMap, que encadeia computações dependentes. Cada etapa pode depender do resultado da anterior.

import cats.Monad
import cats.instances.option._

val m = Monad[Option].flatMap(Some(3))(x => Some(x * 10))
println(m) // Some(30)

Leis da Monad

As monads devem obedecer a três leis:

Identidade à esquerda: pure(a).flatMap(f) == f(a)
Identidade à direita: m.flatMap(pure) == m
Associatividade: flatMaps aninhados podem ser reagrupados

Semigroup e Monoid

Um Semigroup[A] define combine (associativo). Um Monoid[A] adiciona um elemento identidade empty. Eles são a base de reduções e acumulações.

import cats.syntax.semigroup._
import cats.instances.int._
import cats.instances.string._

println(3 |+| 4)       // 7
println("foo" |+| "bar") // foobar

Foldable

Foldable[F] abstrai a redução de uma estrutura. Combinado com Monoid, combineAll reduz uma coleção a um ú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) // 10

Traverse

Traverse[F] permite aplicar uma função a cada elemento, produzindo um efeito, e coletar os resultados, transformando List[F[A]] em 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 que as classes de tipos são importantes

As classes de tipos permitem escrever código que funciona para qualquer tipo que forneça o comportamento necessário. Uma função restrita por Monad[F] funciona para Option, List, IO e muito mais — escreva uma vez e reutilize em qualquer 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))))

Verificação rápida

Qual classe de tipos adiciona flatMap para sequenciar computações dependentes?

Recapitulação

Você explorou a hierarquia central de classes de tipos do Cats:

Functor — map
Applicative — pure e mapN
Monad — flatMap
Semigroup/Monoid — combine/empty
Foldable/Traverse — dobrar e coletar efeitos

A seguir, você conhecerá a mônada IO para modelar efeitos de forma pura.

Perguntas Frequentes

A aula “Classes de tipos do Cats” é grátis?

Sim — o texto completo de “Classes de tipos do Cats” é 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 “Classes de tipos do Cats”?

Functor, Monad etc. 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 1 de 4.

Quanto tempo leva a aula “Classes de tipos do Cats”?

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