Download to read offline
![➔
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](https://image.slidesharecdn.com/macros-160701122430/85/Introduction-to-Scala-Macros-9-320.jpg)
![➔
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](https://image.slidesharecdn.com/macros-160701122430/85/Introduction-to-Scala-Macros-11-320.jpg)
![➔
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](https://image.slidesharecdn.com/macros-160701122430/85/Introduction-to-Scala-Macros-12-320.jpg)
![➔
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](https://image.slidesharecdn.com/macros-160701122430/85/Introduction-to-Scala-Macros-13-320.jpg)
Uploaded byKnoldus Inc.
Introduction to Scala Macros
This document provides an introduction to Scala macros, covering their definitions, uses, and how to write them. It outlines important terminologies, benefits like generating type-checked code, and the necessity for specific library dependencies. Additionally, examples and references related to Scala macros are included for further exploration.
More Related Content
More from Knoldus Inc.
Introduction to Scala Macros
- 1. INTRODUCTION TO SCALAMACROS Jyotsna Karan Software Consultant Knoldus Software LLP
- 2. AGENDA ➔ What are scalamacros ➔ Where macros are used ➔ How to write scala macros ➔ Types of macros ➔ Demo
- 3. ➔ Scala macros wereintroduced 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 needto be familiar before learning scala : ➔ AST ➔ Run-time reflection ➔ DSLs What are Scala Macros
- 5. ➔ Remove redundant code ➔ Replacerun-time reflection ➔ Generates type-checked code ➔ Simplify compiler in long run What they good for?
- 6.
- 7.
- 8. ➔ Macros needs scala-reflect.jarin library dependencies. ➔ The separate compilation restriction requires macros to be placed in a separate project How to write macros?
- 9. ➔ Imports needed formacros 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 isbasically 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 usedwith 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 providedefault 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 definitionscan be annotated ➔ Present in macro paradise library ➔ Static Annotation is the Class need to be extended to use annotations Macros Annotations
- 15.
- 16.
Editor's Notes
- #10 To enable the feature explicitly import are needed At first glance macro definitions are equivalent to normal function definitions, except for their body, which starts with the conditional keyword macro and is followed by a possibly qualified identifier that refers to a static macro implementation method. If, during type-checking, the compiler encounters an application of the macro m(args), it will expand that application by invoking the corresponding macro implementation method, with the abstract-syntax trees of the argument expressions args as arguments. The result of the macro implementation is another abstract syntax tree, which will be inlined at the call site and will be type-checked in turn. where c is a context argument that contains information collected by the compiler at the call site, Expression of same return by should be used Expr -> Scalatype + AST
- #11 Reify is itself a macro to generate macro
- #12 Reify is itself a macro to generate macro
- #13 Reify is itself a macro to generate macro
- #14 Reify is itself a macro to generate macro
- #15 Reify is itself a macro to generate macro