Scala macro is the feature introduced in scala version 2.10, and have an experimental status for now. They are the piece of code that is executed at compile-time. Macro definitions are similar to the normal functions except that the body of these functions starts with keyword macro.

1. INTRODUCTION TO SCALA MACROS
Jyotsna Karan
Software Consultant
Knoldus Software LLP

2. AGENDA
➔
What are scala macros
➔
Where macros are used
➔
How to write scala macros
➔
Types of macros
➔
Demo

3. ➔
Scala macros were introduced in 2013
➔
They are experimental
➔
Written in Scala
➔
The macros are function : code => code
➔
They are like normal functions in look
➔
We already have macros in other languages as well: C, C++,
LISP etc.
What are Scala Macros

4. Terminologies that need to be familiar before learning scala :
➔
AST
➔
Run-time reflection
➔
DSLs
What are Scala Macros

5. ➔
Remove redundant code
➔
Replace run-time reflection
➔
Generates type-checked code
➔
Simplify compiler in long run
What they good for?

6. AST
Run-time reflection
DSLs
What are its cons?

7. ➔
Slick
➔
Akka
➔
MacWire
➔
Expecty
➔
Async
Where macros are used?

8. ➔
Macros needs scala-reflect.jar in library dependencies.
➔
The separate compilation restriction requires macros to be
placed in a separate project
How to write macros?

9. ➔
Imports needed for macros
import language.experimental.macros
import reflect.macros.Context
➔
Syntactical structure of macro
def myFirstMacro():R = macro firstImpl
def firstImpl(c : Context) : c.Expr[R] = {
/* ...... */
}
Def Macros

10. ➔
Context: It is basically the entry point for the macros invocation
➔
Reify: It is used to return the abstract syntax tree
Def Macros

11. ➔
MyFirstMacro will print “hello Macro”
➔
Implementation of this example macro would be like :
def firstImpl(c : Context) : c.Expr[R] = {
reify {
println(“hello Macro”)
}
}
Def Macros

12. ➔
They are used with the type classes
➔
Available since 2013
Type classes: They are just pattern implemented with traits
trait Showable[T] { def show(x: T): String }
def show[T](x : T)(implicit s: Showable[T]) =
s.show
Implicit Macros

13. ➔
We can provide default implementation for the type
trait Showable[T] { def show(x: T) }
object Showable {
implicit materialize[T]: Showable[T] = {
/* macro ..... */
}
}
Implicit Macros

14. ➔
Textual representations
➔
Any definitions can be annotated
➔
Present in macro paradise library
➔
Static Annotation is the Class need to be extended to use
annotations
Macros Annotations

15. ➔
http://docs.scala-lang.org/overviews/macros/overview.html
➔
https://en.wikipedia.org/wiki/Abstract_syntax_tree
➔
http://www.warski.org/blog/2012/12/starting-with-scala-macros-
a-short-tutorial
➔
https://en.wikipedia.org/wiki/Abstract_syntax_tree
References

16. Thank You...