Presentation to go with my talk https://www.youtube.com/watch?v=cD5tCebAdUg

1. Macrobrew: Clojure macros
distilled
Abhinav Omprakash
@the_lazy_folder

2. Tech Talk
@the_lazy_folder

3. Macros look similar to functions
@the_lazy_folder

4. Arguments passed to the macro
are not evaluated
@the_lazy_folder

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

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

7. Data returned by the macro is
evaluated
@the_lazy_folder

8. (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

9. (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

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

11. Double Evaluation
@the_lazy_folder

12. What does a lisper do?
@the_lazy_folder

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

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

15. In lisp, we create lists.
@the_lazy_folder

16. @the_lazy_folder

17. The origin of the mighty macro
@the_lazy_folder

18. @the_lazy_folder

19. Symbols & Values
@the_lazy_folder

20. TABLE
@the_lazy_folder

21. @the_lazy_folder

22. @the_lazy_folder

23. 犬
@the_lazy_folder

24. @the_lazy_folder

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

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

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

28. Symbols can be assigned other
symbols
@the_lazy_folder

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

30. Are symbols values?
@the_lazy_folder

31. Pre-defined vs user-defined
symbols
@the_lazy_folder

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

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

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

35. Revisiting double evaluation
@the_lazy_folder

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

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

38. In functions,
we manipulate values.
@the_lazy_folder

39. In macros,
we manipulate symbols and values.
@the_lazy_folder

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

41. 1 + 2
@the_lazy_folder

42. (1 + 2)
@the_lazy_folder

43. [1 + 2]
@the_lazy_folder

44. ‘(1 + 2)
@the_lazy_folder

45. (+ 1 2)
@the_lazy_folder

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

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

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

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

50. A 3-step process
@the_lazy_folder

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

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

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

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

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

56. (defmacro print-els [coll]
`(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

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

58. =>(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

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

60. The unquote splice aka ~@ operator
(defmacro print-els [coll]
`(do ~@(map println coll)
~coll))
@the_lazy_folder

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

62. Symbol capture
@the_lazy_folder

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

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

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

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

67. (defmacro return-some-list [x]
`(let [one 1]
[one ~x]))
(defmacro return-some-list [x]
`(let [one# 1]
[one# ~x]))
@the_lazy_folder

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

69. Common gotchas
@the_lazy_folder

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

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

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

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

74. 3. Passing a symbol instead of a
value
@the_lazy_folder

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

76. (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

77. Practical Advice
@the_lazy_folder

78. Always use a syntax quote
@the_lazy_folder

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

80. Actions have consequences
@the_lazy_folder

81. Macros are infectious
@the_lazy_folder

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

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

84. (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

85. Macros are not reusable
@the_lazy_folder

86. Macros are not composable
@the_lazy_folder

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

88. When should you write a macro?
@the_lazy_folder

89. When a function just won’t do
@the_lazy_folder

90. When you need to prevent
evaluation of arguments
@the_lazy_folder

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

92. When you want to extend
another macro
@the_lazy_folder

93. Syntactic sugar
@the_lazy_folder

94. Speed
(no, not that kind)
@the_lazy_folder

95. I promised a wedding photo
@the_lazy_folder

96. @the_lazy_folder

97. Thank you
@the_lazy_folder