Scala for Backend Engineering & Functional Programming · Leçon

Classes de types courantes

Show, Ordering, Numeric

Classes de types courantes est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Scala for Backend Engineering & Functional Programming, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Standard Type Classes

Scala's standard library ships several type classes you use daily, sometimes without realizing it:

Ordering[A] — how to compare values.
Numeric[A] — arithmetic over numbers.
Show-style rendering (custom, or Cats' Show).

Ordering Powers sorted

List.sorted needs an implicit Ordering[A]. The standard library provides instances for numbers, strings, and more.

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

Custom Ordering

Pass an explicit Ordering to sort differently, for example descending or by a derived key.

@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 for Case Classes

Provide an Ordering instance for your own type so collections of it can be sorted. Ordering.by derives one from a key.

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 Abstracts Arithmetic

Numeric[A] lets you write functions that work over any number type. sum on a list relies on it.

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

Writing Generic Numeric Code

With a context bound [A: Numeric] you can add or multiply any number type generically. Use the instance's operations via 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)))
  }
}

Numeric Operators

Importing the instance's Implicits gives you the usual operators (+, *) on generic numeric types, making code read naturally.

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

A Show Type Class

Show renders values as text in a type-safe way (unlike toString, which exists on everything). Cats provides it; here is a minimal version.

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 and max/min

Methods like max, min, and maxBy on collections all use Ordering under the hood.

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

Combining Orderings

You can build composite orderings with Ordering.by on a tuple, sorting by one field then another.

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

Why Type Classes Here

Because comparison and arithmetic are type classes, the same sorted or sum works for built-in types and your own, simply by supplying an instance. This is the standard library using ad-hoc polymorphism.

Quick Check

Test your knowledge of standard type classes.

Recap

You met common standard type classes:

Ordering[A] drives sorted, max, min; build with Ordering.by.
Numeric[A] enables generic arithmetic and powers sum.
Show-style classes render values type-safely.

Questions Fréquemment Posées

La leçon « Classes de types courantes » est-elle gratuite ?

Oui — le texte complet de « Classes de types courantes » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Scala for Backend Engineering & Functional Programming, passe à CoddyKit PRO. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Classes de types courantes » ?

Show, Ordering, Numeric Tu pratiques Scala for Backend Engineering & Functional Programming avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Scala for Backend Engineering & Functional Programming ?

Aucune expérience préalable n'est requise. Scala for Backend Engineering & Functional Programming sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Classes de types courantes » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Scala for Backend Engineering & Functional Programming ?

Oui. Chaque leçon Scala for Backend Engineering & Functional Programming inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Scala for Backend Engineering & Functional Programming