0Pricing
Scala for Backend Engineering & Functional Programming · Lektion

Praktische Makros

Anwendungsfälle

Praktische Makros ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 4 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.

Makros in der Praxis

Über Spielzeugbeispiele hinaus lösen Makros konkrete Probleme: Sie erfassen den Quelltextkontext, leiten Typeclasses ab, validieren Literale und generieren Code ohne Boilerplate.

Anwendungsfall: assert mit Nachricht

Ein Makro kann den Quelltext einer fehlgeschlagenen Bedingung erfassen und automatisch eine hilfreiche Assertion-Nachricht erzeugen.

import scala.quoted.*

inline def myAssert(inline cond: Boolean): Unit =
  ${ assertImpl('cond) }

Quellcode erfassen

Innerhalb des Makros liefert cond.show (über die reflect-API) den wörtlichen Quelltext des Ausdrucks. Diesen fügen Sie in die Fehlermeldung ein.

import scala.quoted.*

def assertImpl(cond: Expr[Boolean])(using q: Quotes): Expr[Unit] = {
  import q.reflect.*
  val src = Expr(cond.asTerm.show)
  '{ if (!${ cond }) throw new AssertionError("failed: " + ${ src }) }
}

Anwendungsfall: Validierung zur Compile-Zeit

Validieren Sie ein Literal, beispielsweise einen regulären Ausdruck oder eine Portnummer, bereits zur Compile-Zeit, damit ungültige Werte nie die Laufzeit erreichen.

import scala.quoted.*

inline def port(inline n: Int): Int = ${ portImpl('n) }

Bei ungültiger Eingabe abbrechen

Extrahieren Sie das Literal, prüfen Sie es und rufen Sie bei ungültigen Werten report.errorAndAbort auf. So wird ein Laufzeitfehler in einen Compile-Fehler umgewandelt.

import scala.quoted.*

def portImpl(n: Expr[Int])(using q: Quotes): Expr[Int] = {
  import q.reflect.*
  val v = n.valueOrAbort
  if (v < 1 || v > 65535) report.errorAndAbort("invalid port")
  n
}

Anwendungsfall: Typeclass-Ableitung

Makros können – häufig über inline + scala.deriving.Mirror – Typeclass-Instanzen wie JSON-Encoder für jede Case Class ohne Boilerplate generieren.

import scala.deriving.Mirror

trait Show[T] { def show(t: T): String }

inline def derived[T](using Mirror.Of[T]): Show[T] = ???

Mirror verwenden

Ein Mirror stellt die Feldtypen und Bezeichner eines Produkts zur Compile-Zeit bereit. Zusammen mit inline können Sie die Felder durchlaufen und eine Instanz erstellen.

import scala.deriving.*
import scala.compiletime.*

inline def labels[T](using m: Mirror.ProductOf[T]): List[String] =
  constValueTuple[m.MirroredElemLabels].toList.map(_.toString)

Anwendungsfall: Logging mit Position

Ein Makro kann über die reflect-API ein Position auslesen und Lognachrichten ohne Laufzeitkosten um Datei- und Zeilennummer ergänzen.

import scala.quoted.*

def posImpl(using q: Quotes): Expr[String] = {
  import q.reflect.*
  val p = Position.ofMacroExpansion
  Expr(s"${p.sourceFile.name}:${p.startLine + 1}")
}

Wann Sie Makros NICHT verwenden sollten

Makros sind leistungsfähig, aber aufwendig zu warten und zu debuggen. Bevorzugen Sie zunächst normale Funktionen, Inline-Methoden oder die Ableitung über given. Verwenden Sie Makros erst, wenn sich die Anforderung damit nicht ausdrücken lässt.

Makros testen

Testen Sie das generierte Verhalten wie gewöhnlichen Code. Testen Sie außerdem, dass ungültige Eingaben nicht kompilieren, beispielsweise mit typeCheckErrors aus den Compile-Time-Testwerkzeugen.

Laufzeit-Analogon

Ein Makro zur Validierung zur Compile-Zeit erzielt denselben Effekt wie diese eigenständige Prüfung zur Laufzeit – der Fehler tritt jedoch beim Kompilieren statt zur Laufzeit auf.

object Main {
  def port(n: Int): Int = {
    require(n >= 1 && n <= 65535, "invalid port")
    n
  }
  def main(args: Array[String]): Unit = {
    println(port(8080)) // 8080
  }
}

Kurzer Check

Was ist der wichtigste Vorteil, ein Literal mit einem Makro statt zur Laufzeit zu validieren?

Zusammenfassung

Sie haben praktische Anwendungsfälle für Makros kennengelernt:

  • Quelltext erfassendes assert
  • Validierung zur Compile-Zeit mit errorAndAbort
  • Typeclass-Ableitung über Mirror
  • positionsbezogenes Logging
  • wann Makros vermieden werden sollten und wie man sie testet

Sie haben den Kurs zu Metaprogrammierung und Makros abgeschlossen.

Häufig gestellte Fragen

Ist die Lektion „Praktische Makros“ kostenlos?

Ja — der vollständige Text von „Praktische Makros“ 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 „Praktische Makros“?

Anwendungsfälle 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 4 von 4.

Wie lange dauert die Lektion „Praktische Makros“?

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

  1. Inline-Methoden
  2. Makro-Grundlagen
  3. Quotes und Splices
  4. Praktische Makros
← Zurück zu Scala for Backend Engineering & Functional Programming