Scala for Backend Engineering & Functional Programming · Lektion

Makro-Grundlagen

Code zur Compile-Zeit

Makro-Grundlagen ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Scala for Backend Engineering & Functional Programming-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.

Was ist ein Makro?

Ein Makro ist Code, der zur Kompilierzeit ausgeführt wird, um anderen Code zu erzeugen. Mit Scala-3-Makros können Sie Argumente untersuchen, Ausdrücke erstellen und sie vor der Kompilierung in das Programm einsetzen.

Muster aus Inline und Makro

Ein Makro wird aus einem inline def aufgerufen, das an eine mit ${ ... } markierte Methode delegiert. Das Inline-def ist die öffentliche API; die Makroimplementierung läuft im Compiler.

import scala.quoted.*

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

Der Quotes-Kontext

Jede Makroimplementierung erhält einen impliziten Quotes-Kontext. Er gewährt Zugriff auf die Reflection-API sowie die Möglichkeit, Ausdrücke zu erstellen und einzusetzen.

import scala.quoted.*

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

Expr[T]

Expr[T] repräsentiert einen typisierten Ausdruck des Typs T als Daten zur Kompilierzeit. Makros empfangen und geben Expr-Werte zurück.

Werte in Expr heben

Expr(value) hebt einen zur Laufzeitwert, der im Makro berechnet wurde, in einen Ausdruck, der wieder eingesetzt werden kann. Dies funktioniert für jeden Typ mit einer ToExpr-Instanz.

import scala.quoted.*

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

Konstante Argumente extrahieren

n.value (oder n.valueOrAbort) extrahiert die Konstante hinter einem Expr, wenn das Argument statisch bekannt ist, sodass das Makro darauf basierend verzweigen kann.

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
}

Fehler melden

Verwenden Sie quotes.reflect.report.errorAndAbort, um einen Kompilierungsfehler mit Meldung und Position auszugeben, wenn die Vorbedingungen des Makros nicht erfüllt sind.

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)
}

Wo Makros leben

Makroimplementierungen müssen vor dem Code kompiliert werden, der sie verwendet — typischerweise in einer separaten Datei oder einem separaten Modul. Der Compiler führt sie beim Kompilieren des Aufrufers aus.

Häufige Anwendungsfälle

Makros ermöglichen:

die Ableitung von Typeclasses (z. B. JSON-Codecs)
Validierung zur Kompilierzeit (RegEx, SQL)
Protokollierung mit Erfassung von Quellpositionen
kostenfreie Abstraktionen

Sicherheit und Hygiene

Scala-3-Makros sind hygienisch: Generierte Bezeichner können nicht versehentlich Variablen des Benutzers erfassen, und das Typsystem überprüft den generierten Code. Dadurch werden viele klassische Makrofehler verhindert.

Laufzeitäquivalent

Ein Makro, das eine Potenz zur Kompilierzeit berechnet, erzeugt dasselbe Ergebnis wie diese eigenständige Laufzeitversion — allerdings mit vom Compiler fest eingebauten Multiplikationen.

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
  }
}

Schnelltest

Welcher Typ repräsentiert einen typisierten Ausdruck zur Kompilierzeit, den Makros empfangen und zurückgeben?

Zusammenfassung

Sie haben die Grundlagen von Makros kennengelernt:

Makros laufen zur Kompilierzeit über das Muster inline def ... ${ }
Quotes-Kontext und Expr[T]
Hochheben mit Expr(...) und Extrahieren mit .value
Fehlermeldungen und Hygiene

Als Nächstes: Quotes und Splices.

Häufig gestellte Fragen

Ist die Lektion „Makro-Grundlagen“ kostenlos?

Ja — der vollständige Text von „Makro-Grundlagen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Scala for Backend Engineering & Functional Programming-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Makro-Grundlagen“?

Code zur Compile-Zeit Du übst Scala for Backend Engineering & Functional Programming mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Scala for Backend Engineering & Functional Programming zu starten?

Keine Vorkenntnisse erforderlich. Scala for Backend Engineering & Functional Programming auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Makro-Grundlagen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Scala for Backend Engineering & Functional Programming-Lektion Code schreiben und ausführen?

Ja. Jede Scala for Backend Engineering & Functional Programming-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Scala for Backend Engineering & Functional Programming