Composition des domaines
Construire des modèles plus vastes
Composition des domaines 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.
Construire des modèles plus vastes
Les domaines réels sont assemblés à partir de composants plus petits. Composer des domaines consiste à combiner des ADT, des nouveaux types et des valeurs validées bien modélisés pour obtenir des structures plus grandes, qui restent correctes.
- De petits types ciblés se composent pour former des types plus grands.
- Chaque composant conserve ses propres invariants.
case class Money(cents: Long)
case class Product(name: String, price: Money)
object Main:
def main(args: Array[String]): Unit =
println(Product("Book", Money(1999)))Imbriquer des produits
Composez les types produit en imbriquant des case classes. Chaque niveau ajoute de la structure tout en restant lisible.
case class Address(city: String, zip: String)
case class Customer(name: String, address: Address)
object Main:
def main(args: Array[String]): Unit =
val c = Customer("Ada", Address("London", "E1"))
println(c.address.city)Composer avec des collections
Utilisez List, Map et Set pour modéliser les relations un-à-plusieurs dans votre domaine.
case class Item(name: String, qty: Int)
case class Order(id: Int, items: List[Item])
object Main:
def main(args: Array[String]): Unit =
val order = Order(1, List(Item("pen", 2), Item("ink", 1)))
println(order.items.map(_.qty).sum)Composer des types somme
Les choix plus vastes combinent des choix plus petits. Une variante d’énumération peut elle-même contenir un autre ADT, ce qui permet de superposer les décisions.
enum Payment:
case Card(last4: String)
case Cash
enum Checkout:
case Completed(payment: Payment)
case Abandoned
object Main:
def main(args: Array[String]): Unit =
val c: Checkout = Checkout.Completed(Payment.Card("1234"))
println(c)Fonctions qui composent les domaines
Les opérations métier sont des fonctions pures qui transforment des types d’entrée en types de sortie. Leur composition permet de construire des processus.
case class Cart(total: Long)
case class Receipt(total: Long, tax: Long)
object Main:
def checkout(c: Cart): Receipt =
Receipt(c.total, (c.total * 0.2).toLong)
def main(args: Array[String]): Unit =
println(checkout(Cart(1000)))Composer les validations
Lorsque chaque champ est construit par un constructeur intelligent, composez-les avec une compréhension for. L’objet entier n’est créé que si chaque composant est validé.
object V:
def name(s: String): Option[String] = if s.nonEmpty then Some(s) else None
def age(n: Int): Option[Int] = if n >= 0 then Some(n) else None
case class Person(name: String, age: Int)
object Main:
def make(n: String, a: Int): Option[Person] =
for nm <- V.name(n); ag <- V.age(a) yield Person(nm, ag)
def main(args: Array[String]): Unit =
println(Main.make("Bob", 30))
println(Main.make("", 30))Réduire des données composites
Agrégez les structures composées avec fold, ou avec map et sum. La structure des données guide le calcul.
case class Line(price: Long, qty: Int)
case class Invoice(lines: List[Line])
object Main:
def total(inv: Invoice): Long =
inv.lines.foldLeft(0L)((acc, l) => acc + l.price * l.qty)
def main(args: Array[String]): Unit =
val inv = Invoice(List(Line(100, 2), Line(50, 4)))
println(total(inv))Mettre à jour des modèles immuables
Composez les modifications avec copy, qui renvoie une nouvelle valeur où les champs sélectionnés ont été remplacés. L’original reste inchangé.
case class Account(id: Int, balance: Long)
object Main:
def deposit(a: Account, amt: Long): Account =
a.copy(balance = a.balance + amt)
def main(args: Array[String]): Unit =
val a = Account(1, 100)
println(deposit(a, 50))Modéliser une machine à états
Composez des types somme et des fonctions de transition pour modéliser une machine à états où seules les transitions légales existent.
enum Light:
case Red, Green, Yellow
object Main:
def next(l: Light): Light = l match
case Light.Red => Light.Green
case Light.Green => Light.Yellow
case Light.Yellow => Light.Red
def main(args: Array[String]): Unit =
println(next(Light.Red))
println(next(Light.Green))Superposer le domaine et les opérations
Gardez les types de données purs et placez le comportement dans des fonctions ou des méthodes. Un modèle composé et un ensemble de transformations forment une petite bibliothèque métier.
case class Temp(celsius: Double):
def toF: Double = celsius * 9 / 5 + 32
object Main:
def main(args: Array[String]): Unit =
val t = Temp(25.0)
println(t.toF)Tout assembler
Un modèle complet compose des nouveaux types, des produits, des sommes, des collections et une construction validée. Le résultat est difficile à mal utiliser et facile à comprendre.
- Commencez par construire de petits types.
- Composez-les en agrégats.
- Exprimez les opérations sous forme de fonctions pures.
case class Sku(value: String)
case class Line(sku: Sku, qty: Int)
case class Basket(lines: List[Line]):
def count: Int = lines.map(_.qty).sum
object Main:
def main(args: Array[String]): Unit =
val b = Basket(List(Line(Sku("A"), 2), Line(Sku("B"), 3)))
println(b.count)Vérification rapide
Vérifiez votre compréhension de la composition des domaines.
Récapitulatif
Vous avez appris à composer des domaines.
- Imbriquez produits et sommes pour modéliser des structures riches.
- Utilisez les collections pour les relations un-à-plusieurs.
- Composez les validations avec des compréhensions
for. - Mettez à jour les données de manière immuable avec
copy. - Gardez les données pures et exprimez les opérations sous forme de fonctions.
case class User(id: Int, name: String)
case class Post(author: User, text: String)
object Main:
def main(args: Array[String]): Unit =
val p = Post(User(1, "Ada"), "hello")
println(p.copy(text = "hi"))Questions Fréquemment Posées
La leçon « Composition des domaines » est-elle gratuite ?
Oui — le texte complet de « Composition des domaines » 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 « Composition des domaines » ?
Construire des modèles plus vastes 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 « Composition des domaines » ?
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
- Modélisation avec les ADT
- Constructeurs intelligents
- Nouveaux types
- Composition des domaines