Scala for Backend Engineering & Functional Programming · Leçon

Dérivation des classes de types

Instances automatiques

Dérivation des classes de types est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 4 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.

Qu’est-ce que la dérivation ?

La dérivation de classe de types génère automatiquement des instances à partir de la structure d’un type, afin que vous n’ayez pas à écrire manuellement du code répétitif pour chaque classe de cas. Le compilateur construit l’instance à partir de ses champs.

Le problème du code répétitif

Sans dérivation, chaque nouvelle classe de cas nécessite une instance écrite manuellement. Pour un Show appliqué à vingt classes de cas, cela représente vingt définitions presque identiques. La dérivation supprime cette répétition.

D’abord, la composition manuelle

Avant la dérivation automatique, remarquez que vous pouvez composer manuellement des instances à partir des instances des champs. C’est le principe que la dérivation automatise.

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

Instances inductives

La dérivation fonctionne inductivement : définissez des instances pour les types primitifs, puis combinez-les pour les produits (classes de cas) et les sommes (traits scellés). Une instance dérivée est construite à partir de ses composants.

Le mot-clé derives de Scala 3

Scala 3 prend en charge la clause derives. Une classe de types dotée d’une méthode derived peut être associée à un type avec un seul mot-clé. (Extrait conceptuel ; nécessite une classe de types dérivable.)

enum Color derives CanEqual:
  case Red, Green, Blue

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

Dérivation fondée sur Mirror

La dérivation de Scala 3 utilise scala.deriving.Mirror, qui expose la structure d’un type (types et noms des champs) à la compilation. Une méthode derived parcourt les instances des éléments du miroir pour construire l’ensemble.

Dérivation semi-automatique

Les bibliothèques comme Cats proposent une dérivation semi-automatique : vous l’activez pour chaque type avec une seule ligne telle que deriveShow, ce qui permet de conserver des temps de compilation prévisibles tout en supprimant le code répétitif.

Automatique ou semi-automatique

Deux approches :

Automatique : les instances apparaissent partout où elles sont nécessaires grâce à un import implicite ; c’est pratique, mais cela peut ralentir la compilation.
Semi-automatique : vous écrivez un appel explicite de dérivation pour chaque type ; vous avez davantage de contrôle et les constructions sont plus rapides.

Dérivation pour les traits scellés

Pour une hiérarchie scellée (un type somme), une instance dérivée choisit son comportement selon le sous-type auquel appartient une valeur. Ici, une version manuelle illustre ce que la dérivation automatise.

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

Quand utiliser la dérivation

Utilisez la dérivation lorsque :

Vous avez de nombreux types de données nécessitant la même classe de types (codecs JSON, Show, Eq).
L’instance se déduit mécaniquement de la structure.

Écrivez les instances manuellement lorsque le comportement est personnalisé ou que les performances sont essentielles.

Un exemple d’égalité générique

L’égalité est un exemple classique de classe de types dérivable. Le == standard des classes de cas constitue lui-même une forme d’égalité structurelle que le compilateur génère pour vous.

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

Vérification rapide

Testez votre compréhension de la dérivation.

Récapitulatif

Vous avez appris la dérivation des classes de types :

Les instances sont construites inductivement à partir des instances des champs ou des cas.
Scala 3 utilise Mirror et le mot-clé derives.
Choisissez l’option automatique pour la simplicité, et l’option semi-automatique pour garder le contrôle.
Utilisez-la pour éliminer le code répétitif dans de nombreux types de données.

Questions Fréquemment Posées

La leçon « Dérivation des classes de types » est-elle gratuite ?

Oui — le texte complet de « Dérivation des classes de types » 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 « Dérivation des classes de types » ?

Instances automatiques 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 4 sur 4.

Combien de temps prend la leçon « Dérivation des classes de types » ?

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