Introduction
Macro is a fun and powerful tool, but overuse of the macro could cause harm as well. Please enjoy macros responsibly.
What is macro? A common explanation given is that a macro is a program that is able to take code as an input and output code. While it's true, it might not immediately make sense since Scala programmers are often familiar with higher-order functions like (map {...}) and by-name parameter, which on the surface it might seem like it is passing a block of code around.
Here's an example code from Expecty, an assertion macro that I ported to Scala 3:
scala> import com.eed3si9n.expecty.Expecty.assert
import com.eed3si9n.expecty.Expecty.assert
scala> assert(person.say(word1, word2) == "pong pong")
java.lang.AssertionError: assertion failed
assert(person.say(word1, word2) == "pong pong")
| | | | |
| | ping pong false
| ping pong
Person(Fred,42)
at com.eed3si9n.expecty.Expecty$ExpectyListener.expressionRecorded(Expecty.scala:35)
at com.eed3si9n.expecty.RecorderRuntime.recordExpression(RecorderRuntime.scala:39)
... 36 elided
Had I used by-name argument for assert(...), I could control the timing of getting the result but all I'd get would be false. Instead with a macro, it's able to get the shape of source code person.say(word1, word2) == "pong pong", and programmatically generate the error message that includes the code and each of the values in the expression. Someone could potentially write a code that does that using Predef.assert(...) too, but that would be very tedious to do. This still doesn't cover the full aspect of macros.
A compiler is often thought of as something that translates some source code into a machine code. While certainly that is an aspect of it, a compiler does many more things. Among them is type checking. In addition to generating bytecode (or JS) at the end, Scala compiler acts as a lightweight proof system to catch various things like typos, and making sure that the parameter types are expected. The Java virtual machine is almost completely unaware of the Scala type system. This loss of information is sometimes referred to as type erasure, like it's a bad thing, but this duality of type and runtime enables Scala to exist at all as a guest programming language on JVM, JS, and Native.
For Scala, macro gives us a way to take actions at compile-time, and thus a way to directly talk with Scala's type system. For example, I don't think there's an accurate code one can write to detect if a given type A is a case class at runtime. Using macros this can be written in 5 lines:
import scala.quoted.*
inline def isCaseClass[A]: Boolean = ${ isCaseClassImpl[A] }
private def isCaseClassImpl[A: Type](using qctx: Quotes) : Expr[Boolean] =
import qctx.reflect.*
val sym = TypeRepr.of[A].typeSymbol
Expr(sym.isClassDef && sym.flags.is(Flags.Case))
In the above ${ isCaseClassImpl[A] } is an example of Scala 3 macro, specifically known as splicing.
