Downloaded 23 times
![Implementation of the macro
• The original macro parameter has
• type T
• A macro implementation parameter has
• type c.Expr[T]](https://image.slidesharecdn.com/whatsmacros-140911074309-phpapp01/85/What-s-a-macro-Learning-by-Examples-21-320.jpg)
![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](https://image.slidesharecdn.com/whatsmacros-140911074309-phpapp01/85/What-s-a-macro-Learning-by-Examples-27-320.jpg)
![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}](https://image.slidesharecdn.com/whatsmacros-140911074309-phpapp01/85/What-s-a-macro-Learning-by-Examples-28-320.jpg)
![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)
}](https://image.slidesharecdn.com/whatsmacros-140911074309-phpapp01/85/What-s-a-macro-Learning-by-Examples-35-320.jpg)
More Related Content
Similar to What's a macro?: Learning by Examples
What's a macro?: Learning by Examples
- 1. What's a macro? Learning by Examples Takako Shimamoto BizReach, Inc
- 2. What to TalkAbout • What are macros? • Good thing about macros • Actual use cases of macros • Future of macros
- 3. Are you using macros? If “Yes",
- 4.
- 5. Because • Usingmacros 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 arenecessary? • 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 • Macrosare separate compilation • Macro implementations need to be compiled before the main compilation
- 13.
- 14. Def Macros •Def macros replace well-typed terms with other well-typed terms • Can contain arbitrary Scala constructs
- 15. Practical example ScalaLogging
- 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 themacro • Takes several parameter lists
- 19. Implementation of themacro • Takes several parameter lists First comes a single parameter, of type Context
- 20. Implementation of themacro • 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 themacro • 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 • Usingthe showRaw, it is possible to see the AST
- 24. Goodness • Thehard to comprehend notion of meta programming • def macros are similar to the concept of a typed method call
- 25.
- 26. Where? • Touse macros to automatically generate matchers for any complex type • MatcherMacros trait
- 27. Where? case classCat(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 bymacros 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 themacro • Type tags(actual type arguments) will be passed along when the macro is expanded
- 31. Implementation of themacro • Type tags(actual type arguments) will be passed along when the macro is expanded Come with WeakTypeTag context bounds
- 32. Goodness • DRYapproach • 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.
- 40. Appendix - Whatis Spire? • A numeric library for Scala • Using features such as macros, type classes • Fast and Precise
- 41. Where? • Usingstring interpolation and macros, Spire provides convenient syntax for number types • Evaluated at compile-time
- 42. Macro definition •As usual string interpolation
- 43. Implementation of themacro • Syntax check at compile-time
- 44. Implementation of themacro • 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 weakside.
- 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 • Anew experimental API for metaprogramming • Formerly known as Project Palladium
- 51. scala.meta • Implementedin a library shipped separately from the official Scala distribution • The first milestone release is scheduled for this fall
- 52. The goal ofscala.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 • Macrosare actively used in the OSS library • Can be more efficiently and safely programming • Scala macros are evolving!
- 58.