Scala for Backend Engineering & Functional Programming · Aula

Derivação de classes de tipos

Instâncias automáticas.

Derivação de classes de tipos é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 4 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 é derivação?

A derivação de classe de tipos gera instâncias automaticamente a partir da estrutura de um tipo, para que você não precise escrever código repetitivo manualmente para cada classe de caso. O compilador constrói a instância a partir dos campos.

O problema do código repetitivo

Sem derivação, cada nova classe de caso precisa de uma instância manual. Para um Show aplicado a vinte classes de caso, isso significa vinte definições quase idênticas. A derivação elimina essa repetição.

Composição manual primeiro

Antes da derivação automática, observe que você pode compor instâncias manualmente a partir das instâncias dos campos. Esse é o princípio que a derivação automatiza.

trait Show[A] { def show(a: A): String }

case class User(name: String, age: Int)

object Main {
  implicit val strShow: Show[String] = s => s
  implicit val intShow: Show[Int] = _.toString

  implicit val userShow: Show[User] = (u: User) =>
    s"User(${strShow.show(u.name)}, ${intShow.show(u.age)})"

  def main(args: Array[String]): Unit = {
    println(userShow.show(User("Ann", 30)))
  }
}

Instâncias indutivas

A derivação funciona indutivamente: defina instâncias para tipos primitivos e depois combine-as para produtos (classes de caso) e somas (traits selados). Uma instância derivada é construída a partir de suas partes.

Palavra-chave derives do Scala 3

O Scala 3 aceita a cláusula derives. Uma classe de tipos com um método derived pode ser associada a um tipo usando uma única palavra-chave. (Trecho conceitual; exige uma classe de tipos derivável.)

enum Color derives CanEqual:
  case Red, Green, Blue

@main def run(): Unit =
  println(Color.Red == Color.Red)

Derivação baseada em Mirror

A derivação do Scala 3 usa scala.deriving.Mirror, que expõe a estrutura de um tipo (tipos e nomes dos campos) no momento da compilação. Um método derived percorre as instâncias dos elementos do mirror para construir o conjunto completo.

Derivação semiautomática

Bibliotecas como Cats oferecem derivação semiautomática: você opta por ela para cada tipo com uma única linha, como deriveShow, mantendo os tempos de compilação previsíveis e eliminando o código repetitivo.

Automática versus semiautomática

Há dois estilos:

Automática: as instâncias aparecem onde forem necessárias por meio de uma importação implícita; é conveniente, mas pode deixar a compilação mais lenta.
Semiautomática: você escreve uma chamada explícita de derivação para cada tipo; tem mais controle e gera compilações mais rápidas.

Derivação para traits selados

Em uma hierarquia selada (um tipo soma), uma instância derivada direciona a execução com base no subtipo ao qual um valor pertence. Aqui, uma versão manual mostra a ideia que a derivação automatiza.

trait Show[A] { def show(a: A): String }

sealed trait Shape
case class Circle(r: Int) extends Shape
case class Square(s: Int) extends Shape

object Main {
  implicit val shapeShow: Show[Shape] = {
    case Circle(r) => s"Circle($r)"
    case Square(s) => s"Square($s)"
  }

  def main(args: Array[String]): Unit = {
    println(shapeShow.show(Circle(5)))
    println(shapeShow.show(Square(3)))
  }
}

Quando usar derivação

Use derivação quando:

Você tem muitos tipos de dados que precisam da mesma classe de tipos (codificadores JSON, Show, Eq).
A instância pode ser criada mecanicamente a partir da estrutura.

Escreva instâncias manualmente quando o comportamento for personalizado ou crítico para o desempenho.

Um exemplo de igualdade genérica

Igualdade é uma classe de tipos clássica que pode ser derivada. O == padrão nas classes de caso já é uma forma de igualdade estrutural que o compilador gera para você.

case class Coord(x: Int, y: Int)

object Main {
  def main(args: Array[String]): Unit = {
    println(Coord(1, 2) == Coord(1, 2))
    println(Coord(1, 2) == Coord(3, 4))
  }
}

Verificação rápida

Teste sua compreensão da derivação.

Recapitulação

Você aprendeu sobre a derivação de classes de tipos:

As instâncias são construídas indutivamente a partir das instâncias dos campos e dos casos.
O Scala 3 usa Mirror e a palavra-chave derives.
Escolha a derivação automática por conveniência e a semiautomática por controle.
Use-a para eliminar código repetitivo em muitos tipos de dados.

Perguntas Frequentes

A aula “Derivação de classes de tipos” é grátis?

Sim — o texto completo de “Derivação de classes de tipos” é 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 “Derivação de classes de tipos”?

Instâncias automáticas. 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 4 de 4.

Quanto tempo leva a aula “Derivação de classes de tipos”?

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