Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.

What's a macro?: Learning by Examples / Scalaのマクロに実用例から触れてみよう!

2,445 views

Published on

Presentation material by Ms. Takako Shimamoto at ScalaMatsuri 2014
http://scalamatsuri.org/en/

Published in: Software
  • Be the first to comment

What's a macro?: Learning by Examples / Scalaのマクロに実用例から触れてみよう!

  1. 1. What's a macro? Learning by Examples Takako Shimamoto BizReach, Inc
  2. 2. What to Talk About • What are macros? • Good thing about macros • Actual use cases of macros • Future of macros
  3. 3. Are you using macros? If “Yes",
  4. 4. The Fab You!
  5. 5. Because • Using macros is easy, developing macros is hard
  6. 6. What are macros? • Code that generates code • Not textual code generation
  7. 7. What are macros? • An experimental feature of 2.10+ • Compiler invokes functions
  8. 8. Before macros • Ad-hoc textual code generation by sbt plugin • Compile-time AST operation by compiler plugin
  9. 9. Why macros are necessary? • Code is made simple • Efficiency improved
  10. 10. Macro is on your side!
  11. 11. To use macros • Need to be enabled explicitly • import scala.language.experimental.macros • -language:experimental.macros
  12. 12. Notes • Macros are separate compilation • Macro implementations need to be compiled the main compilation
  13. 13. Def Macros
  14. 14. Def Macros • Def macros replace well-typed terms with other well-typed terms • Can contain arbitrary Scala constructs
  15. 15. Practical example Scala Logging
  16. 16. Where? you call logger.debug(s"Some $expensive message!") replaced by macros if (logger.isDebugEnabled) logger.debug(s"Some $expensive message!")
  17. 17. M • Starts with the conditional keyword • F
  18. 18. I • Takes several parameter lists
  19. 19. I • Takes several parameter lists First comes a single parameter, of type Context
  20. 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. 21. I • The original macro parameter has • type T • A macro implementation parameter has • type c.Expr[T]
  22. 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. 23. Q • Using the showRaw, it is possible to see the AST
  24. 24. Goodness • The hard to comprehend notion of meta programming • def macros are similar to the concept of a typed method call
  25. 25. Practical example specs2
  26. 26. Where? • To use macros to automatically generate matchers for any complex typ • MatcherMacros trait
  27. 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. 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. 29. M • Generics • Has type parameters
  30. 30. I • Type tags(actual type arguments) along when the macro is expanded
  31. 31. I • Type tags(actual type arguments) along when the macro is expanded Come with WeakTypeTag context bounds
  32. 32. Goodness • DRY approach • Usage is fairly simple
  33. 33. Blackbox vs Whitebox • From 2.11 • Not implemented in 2.10 or in macro paradis • in 2.12, only include blackbox macros
  34. 34. Blackbox vs Whitebox • 2.10 • scala.reflect.macros.Context • 2.11 • scala.reflect.macros.blackbox.Context • scala.reflect.macros.whitebox.Context
  35. 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. 36. Why distinction? scala> FooExample.foo res0: Bar = Bar@4118f8dd • Type checking during macro expansion • Not affect after expansion
  37. 37. B • Type parameters of macro affect the type of after macro expansion • When blackbox macro is used, Implicit Macros will not work
  38. 38. No restrictions • Same as 2.10 def macros • E should be possible in 2.11
  39. 39. Practical example Spire
  40. 40. Appendix • A numeric library for Scala • Using features such as macros, type classes • Fast and Precise
  41. 41. Where? • Using string interpolation and macros, Spire provides convenient syntax for number types • Evaluated at compile-time
  42. 42. M • As usual string interpolation
  43. 43. I • Syntax check at compile-time
  44. 44. I • Syntax check at compile-time Occur at compile-time if any errors encounter
  45. 45. Goodness • Static (compile-time) type check • Runtime error decrease
  46. 46. But, has weak side.
  47. 47. Current state • Optimized towards compiler developers, not library users Complicated
  48. 48. Scala 2.12 (plan) • Not introduce new features • Bugfixes and stability improvements • Mention later why reason
  49. 49. scala.meta • A new experimental API for metaprogramming • F
  50. 50. scala.meta • Implemented in a library shipped separately from the official Scala distribution • The first milestone release is scheduled for this fall
  51. 51. The goal of scala.meta • Metaprogramming easy • New API is going to greatly simplify writing macros • Not require knowledge of compiler internals
  52. 52. Language model • All represented with trees Types Modifiers … Names Trees scala.meta Terms Symbols
  53. 53. Language model • Keeps all the information about the program • Comments also remain • No information is lost anymore
  54. 54. Manner of utilization • Code generation • Static type checking • etc…
  55. 55. Summary • Macros are actively used in the OSS library • Can be more efficiently and safely programming • Scala macros are evolving
  56. 56. Thanks!!

×