I'm learning Clojure macros, and wonder why we can't use just functions for metaprogramming.
As far as I know the difference between macro and function is that arguments of macro are not evaluated but passed as data structures and symbols as they are, whereas the return value is evaluated (in the place where macro is called). Macro works as a proxy between reader and evaluator, transforming the form in an arbitrary way before the evaluation takes place. Internally they may use all the language features, including functions, special forms, literals, recursion, other macros etc.
Functions are the opposite. Arguments are evaluated before the call, return value is not after return. But the mirroring nature of macros and functions makes me wonder, couldn't we as well use functions as macros by quoting their arguments (the form), transforming the form, evaluating it inside the function, finally returning it's value. Wouldn't this logically produce the same outcome? Of course this would be inconvenient, but theoretically, is there equivalent function for every possible macro?
Here is simple infix macro
(defmacro infix "translate infix notation to clojure form" [form] (list (second form) (first form) (last form))) (infix (6 + 6)) ;-> 12
Here is same logic using a function
(defn infix-fn "infix using a function" [form] ((eval (second form)) (eval (first form)) (eval (last form)))) (infix-fn '(6 + 6)) ;-> 12
Now, is this perception generalizable to all situations, or are there some corner cases where macro couldn't be outdone? In the end, are macros just a syntactic sugar over a function call?
It would help if I read the question before answering it.
Your infix function doesn't work except with literals:
(let [m 3, n 22] (infix-fn '(m + n)) CompilerException java.lang.RuntimeException: Unable to resolve symbol: m in this context ...
This is the consequence of what @jkinski noted: by the time
m is gone.
Can macros do what functions cannot?
Yes. But if you can do it with a function, you generally should.
Macros are good for
none of which a function can do.
Consider (from Programming Clojure by Halloway & Bedra)
(defmacro unless [test then] (list 'if (list 'not test) then)))
... a partial clone of
if-not. Let's use it to define
(defn safe-div [num denom] (unless (zero? denom) (/ num denom)))
... which prevents division by zero, returning
(safe-div 10 0) => nil
If we tried to define it as a function:
(defn unless [test then] (if (not test) then))
(safe-div 10 0) ArithmeticException Divide by zero ...
The potential result is evaluated as the
then argument to
unless, before the body of
unless ignores it.
Capturing Forms and Re-organizing Syntax
Suppose Clojure had no
case form. Here is a rough-and-ready substitute:
(defmacro my-case [expr & stuff] (let [thunk (fn [form] `(fn  ~form)) pairs (partition 2 stuff) default (if (-> stuff count odd?) (-> stuff last thunk) '(constantly nil)) [ks vs] (apply map list pairs) the-map (zipmap ks (map thunk vs))] (list (list the-map expr default))))
ks) and corresponding expressions (
The details are unimportant. The point is it can be done.
When Guido van Rossum proposed adding a case statement to Python, the committee turned him down. So Python has no case statement. If Rich didn't want a
case statement, but I did, I can have one.
Just for fun, let's use macros to contrive a passable clone of the
if form. This is no doubt a cliche in functional programming circles, but took me by surprise. I had thought of
if as an irreducible primitive of lazy evaluation.
An easy way is to piggy-back on the the
(defmacro if-like ([test then] `(if-like ~test ~then nil)) ([test then else] `(my-case ~test false ~else nil ~else ~then)))
This is prolix and slow, and it uses stack and loses
recur, which gets buried in the closures. However ...
(defn fact [n] (if-like (pos? n) (* (fact (dec n)) n) 1)) (map fact (range 10)) => (1 1 2 6 24 120 720 5040 40320 362880)
... it works, more or less.
Please, dear reader, point out any errors in my code.