Types union et intersection
Nouvelles fonctionnalités des types
Types union et intersection 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.
Nouvelles fonctionnalités de typage
Scala 3 ajoute les types union (A | B) et les types intersection (A & B) au système de types. Ils permettent de décrire les valeurs plus précisément, sans hiérarchies d’héritage.
object Main:
def main(args: Array[String]): Unit =
println("Union: A | B, Intersection: A & B")Principes des types union
Un type union A | B représente une valeur qui est soit un A, soit un B. Il s’agit d’un OU ensembliste appliqué aux types.
object Main:
def show(x: Int | String): String = x match
case i: Int => s"int $i"
case s: String => s"str $s"
def main(args: Array[String]): Unit =
println(show(42))
println(show("hi"))Les unions n’exigent pas de supertype commun
Contrairement à Either de Scala 2, les types union n’exigent pas d’enveloppe. Deux types quelconques peuvent être réunis sans partager de classe parente.
object Main:
def parse(input: Int | Boolean): String =
input match
case n: Int => s"number $n"
case b: Boolean => s"flag $b"
def main(args: Array[String]): Unit =
println(parse(7))
println(parse(true))Les unions pour modéliser les erreurs
Les types union sont pratiques pour représenter des résultats d’erreur légers, sans type enveloppe. Combinés à des énumérations ou à des singletons, ils offrent une lecture claire.
case object NotFound
object Main:
def lookup(id: Int): String | NotFound.type =
if id == 1 then "Alice" else NotFound
def main(args: Array[String]): Unit =
println(lookup(1))
println(lookup(2))Principes des types intersection
Un type intersection A & B représente une valeur qui est à la fois A et B. Il s’agit d’un ET ensembliste, souvent utilisé pour combiner des traits.
trait Named:
def name: String
trait Aged:
def age: Int
object Main:
def describe(p: Named & Aged): String =
s"${p.name} is ${p.age}"
def main(args: Array[String]): Unit =
val person = new Named with Aged:
def name = "Bob"
def age = 40
println(describe(person))L’intersection est commutative
L’ordre n’a pas d’importance pour les types intersection : A & B est le même type que B & A. Cela diffère des types composés A with B de Scala 2, qui dépendaient de l’ordre pour la résolution de certains membres.
trait Readable:
def read: String
trait Writable:
def write(s: String): Unit
object Main:
def use(r: Readable & Writable): Unit =
r.write("x")
println(r.read)
def main(args: Array[String]): Unit =
val rw = new Readable with Writable:
def read = "data"
def write(s: String) = println(s"wrote $s")
use(rw)Combiner plusieurs traits
Vous pouvez intersecter plus de deux types. Le résultat exige toutes les capacités indiquées.
trait A: def a: Int
trait B: def b: Int
trait C: def c: Int
object Main:
def sum(x: A & B & C): Int = x.a + x.b + x.c
def main(args: Array[String]): Unit =
val v = new A with B with C:
def a = 1
def b = 2
def c = 3
println(sum(v))Alias de types pour les unions
Les types union longs peuvent être nommés avec un alias type afin de préserver la lisibilité des signatures.
type Json = Int | String | Boolean
object Main:
def render(j: Json): String = j match
case i: Int => i.toString
case s: String => s"\"$s\""
case b: Boolean => b.toString
def main(args: Array[String]): Unit =
println(render("hi"))
println(render(true))Correspondance exhaustive sur les unions
Le compilateur connaît les membres d’une union, et peut donc vérifier que la correspondance est complète. Traiter chaque possibilité rend le match total.
type Shape = "circle" | "square"
object Main:
def sides(s: Shape): Int = s match
case "circle" => 0
case "square" => 4
def main(args: Array[String]): Unit =
println(sides("square"))Élargissement des unions
Lorsque vous affectez une valeur union à une variable dont le type est inféré, Scala conserve le type union. Sachez toutefois que certaines opérations élargissent le type vers la borne supérieure minimale : ajoutez une annotation lorsque vous souhaitez préserver l’union.
object Main:
def pick(flag: Boolean): Int | String =
if flag then 1 else "one"
def main(args: Array[String]): Unit =
val x: Int | String = pick(false)
println(x)Quand utiliser chaque type
Choisissez l’outil approprié.
- Union : une valeur est l’un de plusieurs types (OU).
- Intersection : une valeur satisfait plusieurs traits à la fois (ET).
- Les unions évitent les types enveloppes ; les intersections évitent les héritages profonds.
trait Logger: def log(s: String): Unit
trait Clock: def now: Long
object Main:
def run(env: Logger & Clock): Unit =
env.log(s"time=${env.now}")
def main(args: Array[String]): Unit =
val env = new Logger with Clock:
def log(s: String) = println(s)
def now = 100L
run(env)Vérification rapide
Vérifiez votre compréhension des types union et intersection.
Récapitulatif
Vous avez appris les types union et intersection de Scala 3.
A | B: la valeur est A ou B, sans enveloppe ni parent commun nécessaires.A & B: la valeur est à la fois A et B ; l’opération est commutative.- Utilisez la correspondance de motifs pour restreindre les unions ; combinez les traits avec les intersections.
- Utilisez des alias de
typepour nommer les unions longues.
object Main:
def length(x: String | List[Int]): Int = x match
case s: String => s.length
case l: List[Int] => l.length
def main(args: Array[String]): Unit =
println(length("hello"))
println(length(List(1, 2, 3)))
Apprends Scala avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 39
- Leçons
- 143
Questions Fréquemment Posées
La leçon « Types union et intersection » est-elle gratuite ?
Oui — le texte complet de « Types union et intersection » 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 union et intersection » ?
Nouvelles fonctionnalités des types 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 « Types union et intersection » ?
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
- Indentation significative
- Énumérations dans Scala 3
- Types opaques
- Types union et intersection