Scala for Backend Engineering & Functional Programming · Leçon

Bases des macros

Code évalué à la compilation

Bases des macros est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 2 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'une macro ?

Une macro est du code exécuté à la compilation pour générer un autre code. Les macros de Scala 3 permettent d'inspecter les arguments, de construire des expressions et de les intégrer au programme avant sa compilation.

Modèle inline + macro

Une macro est appelée depuis une inline def qui délègue à une méthode marquée avec ${ ... }. La définition inline constitue l'API publique ; l'implémentation de la macro s'exécute dans le compilateur.

import scala.quoted.*

inline def power(x: Double, inline n: Int): Double =
  ${ powerImpl('x, 'n) }

Le contexte Quotes

Toute implémentation de macro reçoit un contexte implicite Quotes. Celui-ci donne accès à l'API de réflexion ainsi qu'à la possibilité de construire et d'insérer des expressions.

import scala.quoted.*

def powerImpl(x: Expr[Double], n: Expr[Int])(using Quotes): Expr[Double] =
  ???

Expr[T]

Expr[T] représente une expression typée de type T sous forme de donnée connue à la compilation. Les macros reçoivent et renvoient des valeurs Expr.

Élever des valeurs en Expr

Expr(value) élève une valeur calculée lors de l'exécution de la macro en une expression à réinsérer. Cela fonctionne pour tout type possédant une instance ToExpr.

import scala.quoted.*

def constImpl(using Quotes): Expr[Int] = Expr(42)

Extraire des arguments constants

n.value (ou n.valueOrAbort) extrait la constante contenue dans un Expr lorsque l'argument est connu statiquement, afin que la macro puisse choisir une branche en fonction de cette valeur.

import scala.quoted.*

def powerImpl(x: Expr[Double], n: Expr[Int])(using Quotes): Expr[Double] = {
  val exp = n.valueOrAbort
  ??? // build x*x*...*x exp times
}

Signaler des erreurs

Utilisez quotes.reflect.report.errorAndAbort pour produire une erreur de compilation avec un message et un emplacement lorsque les préconditions de la macro ne sont pas satisfaites.

import scala.quoted.*

def check(n: Expr[Int])(using q: Quotes): Expr[Int] = {
  import q.reflect.*
  val v = n.valueOrAbort
  if (v < 0) report.errorAndAbort("must be >= 0")
  Expr(v)
}

Où résident les macros

Les implémentations de macros doivent être compilées avant le code qui les utilise — généralement dans un fichier ou un module distinct. Le compilateur les exécute lors de la compilation de l'appelant.

Cas d'utilisation courants

Les macros permettent :

la dérivation de classes de types (encodeurs JSON, etc.)
la validation à la compilation (expressions régulières, SQL)
la journalisation qui capture les positions dans le code source
des abstractions sans coût à l'exécution

Sécurité et hygiène

Les macros de Scala 3 sont hygiéniques : les identifiants générés ne peuvent pas capturer accidentellement les variables de l'utilisateur, et le système de types vérifie le code généré, évitant ainsi de nombreux bogues classiques des macros.

Équivalent à l'exécution

Une macro qui calcule une puissance à la compilation produit le même résultat que cette version autonome exécutée normalement — mais les multiplications sont intégrées par le compilateur.

object Main {
  def power(x: Double, n: Int): Double =
    if (n == 0) 1.0 else x * power(x, n - 1)
  def main(args: Array[String]): Unit = {
    println(power(2.0, 3)) // 8.0
  }
}

Vérification rapide

Quel type représente une expression typée connue à la compilation que les macros reçoivent et renvoient ?

Récapitulatif

Vous avez appris les bases des macros :

les macros s'exécutent à la compilation avec le modèle inline def ... ${ }
contexte Quotes et Expr[T]
élévation avec Expr(...) et extraction avec .value
signalement des erreurs et hygiène

Ensuite : quotes et splices.

Questions Fréquemment Posées

La leçon « Bases des macros » est-elle gratuite ?

Oui — le texte complet de « Bases des macros » 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 « Bases des macros » ?

Code évalué à la compilation 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 2 sur 4.

Combien de temps prend la leçon « Bases des macros » ?

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