Scala for Backend Engineering & Functional Programming · Leçon

Citations et interpolations

Le code comme donnée

Leçon 3 sur 413 étapes

Citations et interpolations 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.

Le code comme donnée

La métaprogrammation de Scala 3 traite le code comme une donnée. Un quote capture un fragment de code sous forme d'Expr, et un splice réinsère un Expr dans le code.

Le quote : '{ ... }

'{ expr } transforme une expression en Expr[T]. Le code n'est pas exécuté : il devient une valeur que la macro peut manipuler.

import scala.quoted.*

def greeting(using Quotes): Expr[String] = '{ "Hello, " + "world" }

Le splice : ${ ... }

${ expr } insère un Expr dans un quote qui l'entoure, en assemblant les fragments générés. Quote et splice sont inverses.

import scala.quoted.*

def doubled(x: Expr[Int])(using Quotes): Expr[Int] = '{ ${ x } * 2 }

Insérer des valeurs élevées

Dans un quote, vous pouvez insérer une valeur élevée avec Expr(...) afin d'intégrer une constante connue à la compilation dans le code généré.

import scala.quoted.*

def addN(x: Expr[Int], n: Int)(using Quotes): Expr[Int] =
  '{ ${ x } + ${ Expr(n) } }

Construire récursivement du code

Les macros construisent des expressions complexes en combinant quotes et splices dans des boucles ou par récursivité — par exemple pour déployer une puissance en multiplications répétées.

import scala.quoted.*

def pow(x: Expr[Double], n: Int)(using Quotes): Expr[Double] =
  if (n == 0) '{ 1.0 } else '{ ${ x } * ${ pow(x, n - 1) } }

Faire correspondre des motifs sur des quotes

Vous pouvez déstructurer le code en le comparant à des motifs de quotes. Cela permet d'inspecter la forme d'une expression pour l'optimiser ou la réécrire.

import scala.quoted.*

def optimize(e: Expr[Int])(using Quotes): Expr[Int] = e match {
  case '{ ($a: Int) + 0 } => a
  case _                  => e
}

Type[T] et types quotés

De même que Expr[T] contient une expression, Type[T] contient un type. Utilisez '[T] pour mettre un type sous forme de quote et given Type[T] pour l'insérer là où un type est requis.

import scala.quoted.*

def typeName[T](using t: Type[T], q: Quotes): Expr[String] =
  Expr(Type.show[T])

L'API reflect

Pour les opérations de plus bas niveau, quotes.reflect expose l'arbre syntaxique abstrait (Term, Symbol, TypeRepr), afin que vous puissiez inspecter ou construire du code au-delà de ce que les quotes expriment directement.

import scala.quoted.*

def show(e: Expr[Any])(using q: Quotes): Expr[String] = {
  import q.reflect.*
  Expr(e.asTerm.show)
}

Aller-retour entre les niveaux

Convertissez un Expr en Term avec asTerm, puis reconvertissez-le avec asExpr / asExprOf[T]. Cela fait le lien entre l'API de haut niveau des quotes et l'API de réflexion.

import scala.quoted.*

def ident[T: Type](e: Expr[T])(using q: Quotes): Expr[T] = {
  import q.reflect.*
  e.asTerm.asExprOf[T]
}

Équivalent à l'exécution

La macro récursive de calcul de puissance ci-dessus s'étend en multiplications ordinaires. Cette version autonome exécutée normalement montre le même résultat que produirait le code généré.

object Main {
  def pow(x: Double, n: Int): Double =
    if (n == 0) 1.0 else x * pow(x, n - 1)
  def main(args: Array[String]): Unit = {
    println(pow(3.0, 2)) // 9.0
  }
}

Quote et splice sont inverses

Retenez cette dualité : '{ } élève du code en un Expr ; ${ } réinsère un Expr dans le code. Les imbriquer correctement est au cœur de la construction des macros.

Vérification rapide

Que fait l'opérateur splice ${ x } à l'intérieur d'un quote ?

Réponds-y dans la leçon interactive

Récapitulatif

Vous avez appris les quotes et les splices :

'{ } transforme du code en Expr[T]
${ } insère un Expr dans du code
comparaison de motifs de quotes pour déstructurer le code
Type[T] et l'API reflect

Ensuite : les macros pratiques.

Gratuit pour commencer

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

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Citations et interpolations » est-elle gratuite ?

Oui — le texte complet de « Citations et interpolations » 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 « Citations et interpolations » ?

Le code comme donnée 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 « Citations et interpolations » ?

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