Scala for Backend Engineering & Functional Programming · Lezione

Quote e splice

Codice come dati

Quote e splice è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Scala for Backend Engineering & Functional Programming, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.

Il codice come dato

La metaprogrammazione in Scala 3 considera il codice come dati. Una quote cattura una parte di codice come Expr, mentre una splice reinserisce un Expr nel codice.

La quote: '{ ... }

'{ expr } trasforma un'espressione in un Expr[T]. Il codice non viene eseguito: diventa un valore che la macro può manipolare.

import scala.quoted.*

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

La splice: ${ ... }

${ expr } inserisce un Expr in una quote circostante, collegando tra loro i frammenti generati. Quote e splice sono inverse.

import scala.quoted.*

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

Inserire valori convertiti in espressioni

All'interno di una quote è possibile inserire un valore convertito con Expr(...) per incorporare una costante di compilazione nel codice generato.

import scala.quoted.*

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

Costruire codice ricorsivamente

Le macro costruiscono espressioni complesse combinando quote e splice all'interno di cicli o ricorsioni, ad esempio espandendo una potenza in moltiplicazioni ripetute.

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

Pattern matching sulle quote

È possibile destrutturare il codice confrontandolo con pattern di quote. In questo modo si esamina la struttura di un'espressione per ottimizzarla o riscriverla.

import scala.quoted.*

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

Type[T] e tipi quotati

Così come Expr[T] contiene un'espressione, Type[T] contiene un tipo. Utilizzi '[T] per quotare un tipo e given Type[T] per inserirlo dove è richiesto un tipo.

import scala.quoted.*

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

L'API reflect

Per operazioni di livello più basso, quotes.reflect espone l'albero sintattico astratto (Term, Symbol, TypeRepr), consentendo di esaminare o costruire codice oltre ciò che le quote esprimono direttamente.

import scala.quoted.*

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

Passare da un livello all'altro

Converta un Expr in un Term con asTerm e lo riconverta con asExpr / asExprOf[T]. Questo collega l'API delle quote di alto livello all'API di reflection.

import scala.quoted.*

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

Analogo a runtime

La macro ricorsiva per le potenze qui sopra si espande in semplici moltiplicazioni. Questa versione autonoma a runtime mostra lo stesso risultato prodotto dal codice generato.

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 e splice sono inverse

Ricordi la dualità: '{ } solleva il codice trasformandolo in un Expr; ${ } inserisce un Expr nuovamente nel codice. Annidarle correttamente è il cuore della costruzione delle macro.

Verifica rapida

Che cosa fa l'operatore splice ${ x } all'interno di una quote?

Riepilogo

Ha imparato a usare quote e splice:

'{ } quota il codice trasformandolo in Expr[T]
${ } inserisce un Expr nel codice
pattern matching sulle quote per destrutturare il codice
Type[T] e l'API reflect

Successivo: macro pratiche.

Domande Frequenti

La lezione «Quote e splice» è gratuita?

Sì — il testo completo di «Quote e splice» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Scala for Backend Engineering & Functional Programming, passa a CoddyKit PRO. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.

Cosa imparerò in «Quote e splice»?

Codice come dati Eserciti Scala for Backend Engineering & Functional Programming con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Scala for Backend Engineering & Functional Programming?

Non è richiesta alcuna esperienza precedente. Scala for Backend Engineering & Functional Programming su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Quote e splice»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Scala for Backend Engineering & Functional Programming?

Sì. Ogni lezione Scala for Backend Engineering & Functional Programming include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Scala for Backend Engineering & Functional Programming