Scala for Backend Engineering & Functional Programming · Lección

Quotes y splices

Código como datos

Quotes y splices es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Scala for Backend Engineering & Functional Programming, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.

El código como datos

La metaprogramación de Scala 3 trata el código como datos. Una comilla captura un fragmento de código como un Expr y una inserción vuelve a insertar un Expr en el código.

La comilla: '{ ... }

'{ expr } convierte una expresión en un Expr[T]. El código no se ejecuta: se convierte en un valor que la macro puede manipular.

import scala.quoted.*

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

La inserción: ${ ... }

${ expr } inserta un Expr en una comilla envolvente y une los fragmentos generados. Las comillas y las inserciones son operaciones inversas.

import scala.quoted.*

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

Inserción de valores elevados

Dentro de una comilla puede insertar un valor elevado con Expr(...) para incorporar una constante de tiempo de compilación al código generado.

import scala.quoted.*

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

Construcción recursiva de código

Las macros construyen expresiones complejas combinando comillas e inserciones en bucles o mediante recursión; por ejemplo, pueden desplegar una potencia en multiplicaciones repetidas.

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 sobre comillas

Puede desestructurar código mediante patrones de comillas. Esto permite inspeccionar la forma de una expresión para optimizarla o reescribirla.

import scala.quoted.*

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

Type[T] y tipos entre comillas

Al igual que Expr[T] contiene una expresión, Type[T] contiene un tipo. Use '[T] para poner un tipo entre comillas y given Type[T] para insertarlo donde se necesite un tipo.

import scala.quoted.*

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

La API de reflect

Para trabajos de nivel inferior, quotes.reflect expone el árbol de sintaxis abstracta (Term, Symbol, TypeRepr), lo que permite inspeccionar o construir código más allá de lo que expresan directamente las comillas.

import scala.quoted.*

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

Ida y vuelta entre niveles

Convierta un Expr en un Term con asTerm y vuelva a convertirlo con asExpr / asExprOf[T]. Esto conecta la API de comillas de alto nivel con la API de reflexión.

import scala.quoted.*

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

Análogo en tiempo de ejecución

La macro recursiva de potencias anterior se expande en multiplicaciones sencillas. Esta versión autocontenida en tiempo de ejecución muestra el mismo resultado que produciría el código generado.

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

Las comillas y las inserciones son inversas

Recuerde la dualidad: '{ } eleva código a un Expr; ${ } vuelve a insertar un Expr en el código. Anidarlos correctamente es fundamental para construir macros.

Comprobación rápida

¿Qué hace el operador de inserción ${ x } dentro de una comilla?

Resumen

Ha aprendido sobre comillas e inserciones:

'{ } convierte código en Expr[T]
${ } inserta un Expr en el código
pattern matching de comillas para desestructurar código
Type[T] y la API de reflect

Siguiente: macros prácticas.

Preguntas frecuentes

¿La lección «Quotes y splices» es gratis?

Sí — el texto completo de «Quotes y splices» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Scala for Backend Engineering & Functional Programming, actualiza a CoddyKit PRO. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.

¿Qué aprenderé en «Quotes y splices»?

Código como datos Practicas Scala for Backend Engineering & Functional Programming con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Scala for Backend Engineering & Functional Programming?

No se requiere experiencia previa. Scala for Backend Engineering & Functional Programming en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Quotes y splices»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Scala for Backend Engineering & Functional Programming?

Sí. Cada lección de Scala for Backend Engineering & Functional Programming incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Scala for Backend Engineering & Functional Programming