Macros allow code to generate code by replacing expressions during compilation. They enable simplifying code and improving efficiency. While macros are powerful, their implementation can be complex, requiring knowledge of compiler internals. The scala.meta library aims to simplify metaprogramming by representing programs as trees without losing information, making macros easier to write without deep compiler expertise.

1. What's a macro?
Learning by Examples
Takako Shimamoto
BizReach, Inc

2. What to Talk About
• What are macros?
• Good thing about macros
• Actual use cases of macros
• Future of macros

3. Are you using
macros?
If “Yes",

4. The Fab You!

5. Because
• Using macros is easy, developing macros is hard

6. What are macros?
• Code that generates code
• Not textual code generation

7. What are macros?
• An experimental feature of 2.10+
• Compiler invokes functions

8. Before macros
• Ad-hoc textual code generation by sbt plugin
• Compile-time AST operation by compiler plugin

9. Why macros are necessary?
• Code is made simple
• Efficiency improved

10. Macro is
on your
side!

11. To use macros
• Need to be enabled explicitly
• import scala.language.experimental.macros
• -language:experimental.macros

12. Notes
• Macros are separate compilation
• Macro implementations need to be compiled
the main compilation

13. Def Macros

14. Def Macros
• Def macros replace well-typed terms with other
well-typed terms
• Can contain arbitrary Scala constructs

15. Practical
example
Scala Logging

16. Where?
you call
logger.debug(s"Some $expensive message!")
replaced by macros
if (logger.isDebugEnabled)
logger.debug(s"Some $expensive message!")

17. M
• Starts with the conditional keyword
• F

18. I
• Takes several parameter lists

19. I
• Takes several parameter lists
First comes a single
parameter, of type
Context

20. I
• Takes several parameter lists
Macro definition
Next, followed by a list of
parameters that have the
same names as the macro
definition parameters

21. I
• The original macro parameter has
• type T
• A macro implementation parameter has
• type c.Expr[T]

22. Q
• q"..." string interpolators that build code
• Unnecessary to directly implement the AST
• To use the quasiquotes from the macro, just write
import c.universe._

23. Q
• Using the showRaw, it is possible to see the AST

24. Goodness
• The hard to comprehend notion of meta
programming
• def macros are similar to the concept of a typed
method call

25. Practical
example
specs2

26. Where?
• To use macros to automatically generate matchers
for any complex typ
• MatcherMacros trait

27. Where?
case class Cat(name: String, age: Int)
!
// your test case
val cat = Cat(name = "Tom", age = 2)
cat must matchA[Cat].name("Tom")
you call

28. Where?
replaced by macros
def matchACat(
name: Matcher[String] = AlwaysMatcher(),
age: Matcher[Int] = AlwaysMatcher()
): Matcher[Cat] =
name ^^ {(cat: Cat) => cat.name} and
age ^^ {(cat: Cat) => cat.age}

29. M
• Generics
• Has type parameters

30. I
• Type tags(actual type arguments)
along when the macro is expanded

31. I
• Type tags(actual type arguments)
along when the macro is expanded
Come with
WeakTypeTag
context bounds

32. Goodness
• DRY approach
• Usage is fairly simple

33. Blackbox vs Whitebox
• From 2.11
• Not implemented in 2.10 or in macro paradis
• in 2.12, only include blackbox macros

34. Blackbox vs Whitebox
• 2.10
• scala.reflect.macros.Context
• 2.11
• scala.reflect.macros.blackbox.Context
• scala.reflect.macros.whitebox.Context

35. Why distinction?
• Type specification of macro is
class Foo
class Bar extends Foo
Scala 2.10
!
object FooExample {
def foo: Foo = macro foo_impl
def foo_impl(c: Context): c.Expr[Foo] =
c.Expr[Foo](c.universe.reify(new Bar).tree)
}

36. Why distinction?
scala> FooExample.foo
res0: Bar = Bar@4118f8dd
• Type checking during macro expansion
• Not affect after expansion

37. B
• Type parameters of macro affect the type of after
macro expansion
• When blackbox macro is used,
Implicit Macros will not work

38. No restrictions
• Same as 2.10 def macros
• E
should be possible in 2.11

39. Practical
example
Spire

40. Appendix
• A numeric library for Scala
• Using features such as macros, type classes
• Fast and Precise

41. Where?
• Using string interpolation and macros, Spire
provides convenient syntax for number types
• Evaluated at compile-time

42. M
• As usual
string interpolation

43. I
• Syntax check at compile-time

44. I
• Syntax check at compile-time
Occur at compile-time
if any errors
encounter

45. Goodness
• Static (compile-time) type check
• Runtime error decrease

46. But, has
weak side.

47. Current state
• Optimized towards compiler developers, not library
users
Complicated

49. Scala 2.12 (plan)
• Not introduce new features
• Bugfixes and stability improvements
• Mention later why reason

50. scala.meta
• A new experimental API for metaprogramming
• F

51. scala.meta
• Implemented in a library shipped separately from
the official Scala distribution
• The first milestone release is scheduled for this fall

52. The goal of scala.meta
• Metaprogramming easy
• New API is going to greatly simplify writing
macros
• Not require knowledge of compiler internals

53. Language model
• All represented with trees
Types
Modifiers
…
Names
Trees
scala.meta
Terms
Symbols

54. Language model
• Keeps all the information about the program
• Comments also remain
• No information is lost anymore

56. Manner of utilization
• Code generation
• Static type checking
• etc…

57. Summary
• Macros are actively used in the OSS library
• Can be more efficiently and safely programming
• Scala macros are evolving

58. Thanks!!