Scala for Backend Engineering & Functional Programming · Aula

Quotes e splices

Código como dados.

Aula 3 de 413 etapas

Quotes e splices é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

Código como Dados

A metaprogramação do Scala 3 trata o código como dados. Um quote captura um trecho de código como um Expr, e um splice insere um Expr de volta no código.

O Quote: '{ ... }

'{ expr } transforma uma expressão em um Expr[T]. O código não é executado — torna-se um valor que a macro pode manipular.

import scala.quoted.*

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

O Splice: ${ ... }

${ expr } insere um Expr em um quote ao redor, unindo fragmentos gerados. Quote e splice são operações inversas.

import scala.quoted.*

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

Inserindo Valores Elevados

Dentro de um quote, você pode inserir um valor elevado com Expr(...) para incorporar uma constante de tempo de compilação ao código gerado.

import scala.quoted.*

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

Construindo Código Recursivamente

As macros constroem expressões complexas combinando quotes e splices em laços ou recursão — por exemplo, desenrolando uma potência em multiplicações 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) } }

Correspondência de Padrões em Quotes

Você pode desestruturar código fazendo correspondência com padrões de quote. Isso inspeciona a forma de uma expressão para otimizá-la ou reescrevê-la.

import scala.quoted.*

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

Type[T] e Tipos entre Quotes

Assim como Expr[T] carrega uma expressão, Type[T] carrega um tipo. Use '[T] para colocar um tipo em um quote e given Type[T] para inseri-lo onde um tipo for necessário.

import scala.quoted.*

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

A API de reflexão

Para trabalhos de nível mais baixo, quotes.reflect expõe a árvore de sintaxe abstrata (Term, Symbol, TypeRepr), permitindo inspecionar ou construir código além do que os quotes expressam diretamente.

import scala.quoted.*

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

Ida e Volta entre Níveis

Converta um Expr em um Term com asTerm e faça o caminho inverso com asExpr / asExprOf[T]. Isso conecta a API de alto nível de quotes à API de reflexão.

import scala.quoted.*

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

Análogo em Tempo de Execução

A macro recursiva de potência acima é expandida em multiplicações simples. Esta versão independente em tempo de execução mostra o mesmo resultado que o código gerado produziria.

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 são Inversos

Lembre-se da dualidade: '{ } eleva código a um Expr; ${ } devolve um Expr ao código. Aninhá-los corretamente é o cerne da construção de macros.

Verificação Rápida

O que o operador de splice ${ x } faz dentro de um quote?

Responda na aula interativa

Recapitulação

Você aprendeu citações e splices:

'{ } cita código como Expr[T]
${ } insere um Expr no código
correspondência de padrões de citação para decompor o código
Type[T] e a API de reflect

A seguir: macros práticas.

Grátis para começar

Aprenda Scala com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 39
Aulas: 143

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Quotes e splices” é grátis?

Sim — o texto completo de “Quotes e splices” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

O que vou aprender em “Quotes e splices”?

Código como dados. Você pratica Scala for Backend Engineering & Functional Programming com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Scala for Backend Engineering & Functional Programming?

Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Quotes e splices”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Scala for Backend Engineering & Functional Programming?

Sim. Cada aula de Scala for Backend Engineering & Functional Programming inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Scala for Backend Engineering & Functional Programming