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

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

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

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

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

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

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

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

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

56.
Thanks!!