Scala for Backend Engineering & Functional Programming · Aula

Classes de tipos comuns

Show, Ordering, Numeric.

Classes de tipos comuns é 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.

Classes de tipos padrão

A biblioteca padrão do Scala fornece várias classes de tipos que você usa diariamente, às vezes sem perceber:

Ordering[A] — como comparar valores.
Numeric[A] — operações aritméticas com números.
Renderização no estilo de Show (personalizada ou com o Show do Cats).

Ordering potencializa sorted

List.sorted precisa de um Ordering[A] implícito. A biblioteca padrão fornece instâncias para números, strings e outros tipos.

@main def run(): Unit = {
  println(List(3, 1, 2).sorted)
  println(List("pear", "apple", "fig").sorted)
}

Ordering personalizado

Passe um Ordering explícito para ordenar de outra forma, por exemplo, em ordem decrescente ou por uma chave derivada.

@main def run(): Unit = {
  val nums = List(3, 1, 2)
  println(nums.sorted(Ordering.Int.reverse))
  val words = List("bbb", "a", "cc")
  println(words.sortBy(_.length))
}

Ordering para classes de caso

Forneça uma instância de Ordering para seu próprio tipo, para que coleções desse tipo possam ser ordenadas. Ordering.by deriva uma instância a partir de uma chave.

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

object Main {
  implicit val byAge: Ordering[Person] = Ordering.by(_.age)

  def main(args: Array[String]): Unit = {
    val people = List(Person("A", 30), Person("B", 20))
    println(people.sorted)
  }
}

Numeric abstrai a aritmética

Numeric[A] permite escrever funções que funcionam com qualquer tipo numérico. O método sum em uma lista depende dele.

@main def run(): Unit = {
  println(List(1, 2, 3).sum)
  println(List(1.5, 2.5).sum)
}

Escrevendo código numérico genérico

Com um limite de contexto [A: Numeric], você pode somar ou multiplicar qualquer tipo numérico de forma genérica. Use as operações da instância por meio de Numeric[A].

object Main {
  def addAll[A: Numeric](xs: List[A]): A = {
    val num = implicitly[Numeric[A]]
    xs.foldLeft(num.zero)(num.plus)
  }

  def main(args: Array[String]): Unit = {
    println(addAll(List(1, 2, 3)))
    println(addAll(List(1.0, 2.0, 3.5)))
  }
}

Operadores numéricos

Importar os Implicits da instância fornece os operadores usuais (+, *) para tipos numéricos genéricos, fazendo o código parecer natural.

object Main {
  def square[A](a: A)(implicit num: Numeric[A]): A = {
    import num._
    a * a
  }

  def main(args: Array[String]): Unit = {
    println(square(5))
    println(square(2.5))
  }
}

Uma classe de tipos Show

Show renderiza valores como texto de maneira segura quanto aos tipos (diferentemente de toString, que existe em tudo). O Cats fornece essa classe; aqui está uma versão mínima.

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

object Show {
  implicit val intShow: Show[Int] = n => s"Int($n)"
  def apply[A](implicit s: Show[A]): Show[A] = s
}

object Main {
  def main(args: Array[String]): Unit = {
    println(Show[Int].show(42))
  }
}

Ordering e máximo/mínimo

Métodos como max, min e maxBy em coleções usam Ordering internamente.

@main def run(): Unit = {
  val xs = List(4, 9, 1, 7)
  println(xs.max)
  println(xs.min)
  println(List("a", "abc", "ab").maxBy(_.length))
}

Combinando Orderings

Você pode criar orderings compostos com Ordering.by aplicado a uma tupla, ordenando primeiro por um campo e depois por outro.

case class Rec(group: String, score: Int)

object Main {
  implicit val ord: Ordering[Rec] = Ordering.by(r => (r.group, -r.score))

  def main(args: Array[String]): Unit = {
    val data = List(Rec("b", 5), Rec("a", 1), Rec("a", 9))
    data.sorted.foreach(println)
  }
}

Por que usar classes de tipos aqui

Como comparação e aritmética são classes de tipos, o mesmo sorted ou sum funciona com tipos integrados e com os seus próprios tipos, bastando fornecer uma instância. Essa é a biblioteca padrão usando polimorfismo ad hoc.

Verificação rápida

Teste seus conhecimentos sobre as classes de tipos padrão.

Recapitulação

Você conheceu classes de tipos padrão comuns:

Ordering[A] controla sorted, max e min; crie-o com Ordering.by.
Numeric[A] permite aritmética genérica e fornece suporte a sum.
Classes no estilo de Show renderizam valores com segurança quanto aos tipos.

Perguntas Frequentes

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

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

Show, Ordering, Numeric. 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 “Classes de tipos comuns”?

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