Since 2.10.0 Scala includes macros. I was talk about something like the following: * What do macros benefit to us? * What can we do with macros? * Actual use cases

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 before
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. Macro definition
• Starts with the conditional keyword macro
• Followed by a static macro implementation method

18. Implementation of the macro
• Takes several parameter lists

19. Implementation of the macro
• Takes several parameter lists
First comes a single
parameter, of type
Context

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

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

22. Quasiquotes
• 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. Quasiquotes
• 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 type
• 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. Macro definition
• Generics
• Has type parameters

30. Implementation of the macro
• Type tags(actual type arguments) will be passed
along when the macro is expanded

31. Implementation of the macro
• Type tags(actual type arguments) will be passed
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 paradise
• 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 curious
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. Blackbox restrictions
• Type parameters of macro affect the type of after
macro expansion
• When blackbox macro is used, techniques such as
Implicit Macros will not work

38. No restrictions Whitebox
• Same as 2.10 def macros
• Everything that could be done with macros in 2.10
should be possible in 2.11

39. Practical
example
Spire

40. Appendix - What is Spire?
• 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. Macro definition
• As usual
string interpolation

43. Implementation of the macro
• Syntax check at compile-time

44. Implementation of the macro
• 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
• Formerly known as Project Palladium

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