Macrobrew: Clojure macros distilled

Macrobrew: Clojure macros
distilled
Abhinav Omprakash
@the_lazy_folder

Macros look similar to functions
@the_lazy_folder

Arguments passed to the macro
are not evaluated
@the_lazy_folder

(defn func [x]
(println "inside the body")
x)
=>(func (println "hey!"))
hey!
inside the body
nil
@the_lazy_folder

(defmacro mac [x]
(println "inside the body")
x)
=>(mac (println "hey!"))
inside the body
hey!
nil
@the_lazy_folder

Data returned by the macro is
evaluated
@the_lazy_folder

(defn foo []
(list 1 2 3))
=>(foo)
(1 2 3)
=>(eval (foo))
; Execution error (ClassCastException); class
;java.lang.Long cannot be cast to class
clojure.lang.IFn
@the_lazy_folder

(defmacro foo []
(list 1 2 3))
=>(foo)
; Execution error (ClassCastException
; class java.lang.Long cannot be cast to class
clojure.lang.Ifn
@the_lazy_folder

=>(macroexpand '(foo))
(1 2 3)
@the_lazy_folder

Double Evaluation
@the_lazy_folder

What does a lisper do?
@the_lazy_folder

(func arg1 arg2)
‘(1 2 3)
@the_lazy_folder

user=> (count '(func arg1 arg2))
3
user=> (count '(1 2 3))
3
@the_lazy_folder

In lisp, we create lists.
@the_lazy_folder

The origin of the mighty macro
@the_lazy_folder

Symbols & Values
@the_lazy_folder

(def one 7)
user=> one
7
@the_lazy_folder

user=> 'one
one
user=> `one
user/one
@the_lazy_folder

(def one 7)
user=> (eval 'one)
7
@the_lazy_folder

Symbols can be assigned other
symbols
@the_lazy_folder

(def two ‘one)
user=> two
one
user=> (eval (two))
7
@the_lazy_folder

Are symbols values?
@the_lazy_folder

Pre-defined vs user-defined
symbols
@the_lazy_folder

420
[1 2 3]
"Not-a-string"
@the_lazy_folder

(defn add [& nums]
(apply + nums))
@the_lazy_folder

(defn add-2 [num1 num2]
(add num1 num2))
@the_lazy_folder

Revisiting double evaluation
@the_lazy_folder

symbols Value?
(write time)
Value?
(Compile
time)
Value?
(run time)
Predefined
symbols
NO Yes Yes
User defined
symbols
NO No yes
@the_lazy_folder

In functions,
we manipulate values.
@the_lazy_folder

In macros,
we manipulate symbols and values.
@the_lazy_folder

Let’s write a macro
(finally!)
@the_lazy_folder

(1 + 2) => (+ 1 2)
@the_lazy_folder

(lt op rt) => (op lt rt)
@the_lazy_folder

(defmacro infix
[[lt op rt]]
`(~op ~lt ~rt))
@the_lazy_folder

=>(infix (1 + 2))
3
@the_lazy_folder

A 3-step process
@the_lazy_folder

1. Think about the data the macro will get.
(1 + 2)
@the_lazy_folder

2. Think about the data the macro will return.
(+ 1 2)
@the_lazy_folder

3. Think about how to transform that data.
(1 + 2) => (+ 1 2)
@the_lazy_folder

user=>(print-els [1 2 3])
1
2
3
[1 2 3]
@the_lazy_folder

(defmacro print-els [coll]
`(do ~(map println coll)
~coll))
@the_lazy_folder

`(do ~(map println coll)
~coll))
user=>(print-els [1 2 3])
1
2
3
; Syntax error (IllegalArgumentException)
; Can't call nil, form: (nil nil nil)
@the_lazy_folder

(macroexpand-1 '(print-els [1 2 3]))
1
2
3
(do (nil nil nil) [1 2 3])
@the_lazy_folder

=>(do (map println [1 2 3]))
1
2
3
(nil nil nil)
=>(do nil nil nil [1 2 3])
[1 2 3]
@the_lazy_folder

=>(macroexpand-1 '(print-els [1 2 3]))
;expected
(do nil nil nil [1 2 3])
@the_lazy_folder

The unquote splice aka ~@ operator
`(do ~@(map println coll)
~coll))
@the_lazy_folder

user=>(macroexpand-1 '(print-els [1 2 3]))
1
2
3
(do nil nil nil [1 2 3])
@the_lazy_folder

Symbol capture
@the_lazy_folder

(defmacro return-some-list [x]
(list 'let ['one 1]
['one x]))
user=>(return-some-list 5)
[1 5]
@the_lazy_folder

(def one "one")
user=>(return-some-list one)
[1 1]
@the_lazy_folder

user=>(macroexpand-1 '(return-some-list one))
(let [one 1] [one one])
@the_lazy_folder

The autogensym aka #
=>`one#
one__9411__auto__
@the_lazy_folder

`(let [one 1]
[one ~x]))
`(let [one# 1]
[one# ~x]))
@the_lazy_folder

(def one "one")
user=>(return-some-list one)
[1 "one"]
@the_lazy_folder

Common gotchas
@the_lazy_folder

1. Not resolving arguments to a
value inside the macro
@the_lazy_folder

(defmacro infix [[lt op rt]]
‘(op lt rt))
=>(macroexpand-1 '(infix (1 + 2)))
(op lt rt)
@the_lazy_folder

2. The macro is NOT the first
element in the list
@the_lazy_folder

(map infix [(1 + 2) (3 + 4)])
@the_lazy_folder

3. Passing a symbol instead of a
value
@the_lazy_folder

(defmacro mul-2 [xs]
`(* 2 ~@xs))
=>(mul-2 [1 2])
4
@the_lazy_folder

(defmacro mul-2 [xs]
`(* 2 ~@xs))
(defn multiply-by-2 [nums]
(mul-2 nums))
; Syntax error
; Don't know how to create ISeq from:
clojure.lang.Symbol
@the_lazy_folder

Practical Advice
@the_lazy_folder

Always use a syntax quote
@the_lazy_folder

“Don’t write a macro”
-Not me
@the_lazy_folder

Actions have consequences
@the_lazy_folder

Macros are infectious
@the_lazy_folder

(defmacro add [& args]
`(+ ~@args))
user=>(add 1 2 3)
6
@the_lazy_folder

=>(map #(apply + %) [[1 2 3] [2 4]])
(6 6)
@the_lazy_folder

(defmacro add-vecs [vecs]
(loop [f (first vecs)
r (rest vecs)
res `(list)]
(if (seq r)
(recur (first r) (rest r) (concat
res `((add ~@f))))
(concat res `((add ~@f))))))
user=> (add-vecs [[1 2] [3 4]])
(3 7) @the_lazy_folder

Macros are not reusable
@the_lazy_folder

Macros are not composable
@the_lazy_folder

Composition is king.
(even the OO folks know that)
@the_lazy_folder

When should you write a macro?
@the_lazy_folder

When a function just won’t do
@the_lazy_folder

When you need to prevent
evaluation of arguments
@the_lazy_folder

Incanter’s infix notation
User=> ($= 7 + 8 - 2)
13
@the_lazy_folder

When you want to extend
another macro
@the_lazy_folder

Syntactic sugar
@the_lazy_folder

Speed
(no, not that kind)
@the_lazy_folder

I promised a wedding photo
@the_lazy_folder

Macrobrew: Clojure macros distilled

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Macrobrew: Clojure macros distilled

Similaire à Macrobrew: Clojure macros distilled (20)

Dernier

Dernier (20)

Macrobrew: Clojure macros distilled

Notes de l'éditeur