Types de données algébriques
Modélisez votre domaine
Types de données algébriques 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.
Qu’est-ce qu’un ADT ?
Un type de données algébrique (ADT) est un type construit en combinant d’autres types. En Scala, vous modélisez les ADT avec un sealed trait et des variantes case class et case object.
Les ADT vous permettent de décrire précisément la forme des données de votre domaine.
Types somme
Un type somme signifie qu’une valeur est l’une de plusieurs possibilités (un OR). Un feu de circulation est Rouge OR Jaune OR Vert.
Vous l’exprimez avec un trait sealed et plusieurs variantes.
sealed trait Light
case object Red extends Light
case object Yellow extends Light
case object Green extends Light
object Main {
def main(args: Array[String]): Unit = {
val l: Light = Yellow
println(l)
}
}Types produit
Un type produit signifie qu’une valeur combine plusieurs champs (un AND). Un point possède un x AND un y.
Les classes case sont des types produit.
case class Point(x: Int, y: Int)
object Main {
def main(args: Array[String]): Unit = {
val p = Point(3, 4)
println(s"${p.x} and ${p.y}")
}
}Combiner somme et produit
Les ADT réels combinent les deux : un trait scellé (somme) dont les variantes sont des classes de cas (produits).
Ici, une Shape est soit un Circle (avec un rayon), soit un Rectangle (avec une largeur et une hauteur).
sealed trait Shape
case class Circle(radius: Double) extends Shape
case class Rectangle(w: Double, h: Double) extends Shape
object Main {
def main(args: Array[String]): Unit = {
val s: Shape = Rectangle(3, 4)
println(s)
}
}Opérer sur un ADT
Vous traitez un ADT en effectuant une correspondance de motifs sur ses variantes. Chaque branche gère une forme.
sealed trait Shape
case class Circle(radius: Double) extends Shape
case class Rectangle(w: Double, h: Double) extends Shape
object Main {
def area(s: Shape): Double = s match {
case Circle(r) => 3.14159 * r * r
case Rectangle(w, h) => w * h
}
def main(args: Array[String]): Unit = {
println(area(Circle(2)))
println(area(Rectangle(3, 4)))
}
}Modéliser un domaine
Les ADT rendent les états invalides impossibles à représenter. Modélisez une méthode de paiement comme un ensemble fermé d’options valides.
sealed trait PaymentMethod
case class CreditCard(number: String) extends PaymentMethod
case class BankTransfer(iban: String) extends PaymentMethod
case object Cash extends PaymentMethod
object Main {
def main(args: Array[String]): Unit = {
val m: PaymentMethod = Cash
println(m)
}
}ADT récursifs
Un ADT peut se référer à lui-même, ce qui permet de modéliser des arbres et des listes. Voici un arbre binaire simple.
sealed trait Tree
case object Leaf extends Tree
case class Node(value: Int, left: Tree, right: Tree) extends Tree
object Main {
def main(args: Array[String]): Unit = {
val t: Tree = Node(1, Leaf, Node(2, Leaf, Leaf))
println(t)
}
}Parcourir un ADT récursif par pliage
La récursion associée à la correspondance de motifs permet de traiter toute la structure. Ici, nous additionnons toutes les valeurs d’un arbre.
sealed trait Tree
case object Leaf extends Tree
case class Node(value: Int, left: Tree, right: Tree) extends Tree
object Main {
def sum(t: Tree): Int = t match {
case Leaf => 0
case Node(v, l, r) => v + sum(l) + sum(r)
}
def main(args: Array[String]): Unit = {
val t = Node(1, Node(2, Leaf, Leaf), Node(3, Leaf, Leaf))
println(sum(t))
}
}Pourquoi les ADT ?
Les ADT sont puissants parce qu’ils :
- décrivent précisément les données sous forme de sommes et de produits
- rendent impossible la construction d’états illégaux
- s’associent parfaitement à la correspondance exhaustive de motifs
- s’adaptent aux structures récursives comme les arbres et les listes
ADT et héritage
La programmation orientée objet traditionnelle disperserait le comportement entre les sous-classes. Les ADT gardent les définitions de données fermées et placent le comportement dans des fonctions qui effectuent une correspondance de motifs.
Cette séparation des données et du comportement est une caractéristique majeure de la conception fonctionnelle.
Assembler le tout
Un petit ADT complet avec une fonction qui gère chaque variante.
sealed trait Json
case class JNum(n: Double) extends Json
case class JStr(s: String) extends Json
case object JNull extends Json
object Main {
def render(j: Json): String = j match {
case JNum(n) => n.toString
case JStr(s) => "\"" + s + "\""
case JNull => "null"
}
def main(args: Array[String]): Unit = {
List(JNum(3.0), JStr("hi"), JNull).foreach(j => println(render(j)))
}
}Vérification rapide
Vérifiez votre compréhension des ADT.
Récapitulatif
Vous avez appris à construire des types de données algébriques :
- Types somme : trait scellé avec plusieurs variantes (OR)
- Types produit : classes de cas avec des champs (AND)
- à les combiner pour modéliser précisément des domaines
- les ADT peuvent être récursifs (arbres, listes)
- à les traiter avec la correspondance de motifs
Questions Fréquemment Posées
La leçon « Types de données algébriques » est-elle gratuite ?
Oui — le texte complet de « Types de données algébriques » 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 « Types de données algébriques » ?
Modélisez votre domaine 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 « Types de données algébriques » ?
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
- Classes case
- Traits scellés
- Types de données algébriques
- Correspondance exhaustive