Evaluating macro arguments in clojure

Question

I'm trying to translate the following macro from land of lisp into clojure:

(defmacro tag (name atts &body body)
  `(progn (print-tag ',name
                     (list ,@(mapcar (lambda (x)
                                       `(cons ',(car x) ,(cdr x)))
                                     (pairs atts)))
                     nil)
          ,@body
          (print-tag ',name nil t)))

But I keep getting stuck with atts requiring 1 more level of evaluation. E.g. the following needs to evaluate t#:

(defmacro tag [tname atts & body]
  `(do (print-tag '~tname '[~@(map (fn [[h# t#]] [h# t#]) (pair atts))] nil)
     ~@body
     (print-tag '~tname nil true)))

As it produces stuff like:

(tag mytag [color 'blue size 'big])
<mytag color="(quote blue)" size="(quote big)"><\mytag>

Where I want the attribute to evaluated. If I use "(eval t#)" in the above I fall foul of problems like this:

(defn mytag [col] (tag mytag [colour col]))
java.lang.UnsupportedOperationException: Can't eval locals (NO_SOURCE_FILE:1)

Any suggestions?

Why does it seem like one less level of evaluation happens in Clojure?

Definitions of supporting functions:

;note doesn't handle nils because I'm dumb
(defn pair [init-lst]
      (loop [lst init-lst item nil pairs []]
    (if (empty? lst)
      pairs
      (if item
        (recur (rest lst) nil (conj pairs [item (first lst)]))
        (recur (rest lst) (first lst) pairs)))))

(defn print-tag [name alst closing]
      (print "<")
      (when closing
    (print "\\"))
      (print name)
      (doall
      (map (fn [[h t]]
           (printf " %s=\"%s\"" h t))
       alst))
      (print ">"))

(For some reason I didn't do the pair function in the same way as the book which means it doesn't handle nils correctly)

seems to me that `pair` is the same of `(partition 2 seq)`, right? — skuro, Aug 06 '11 at 18:06
@Adrian Mouat: If I had a solution for your problem I would have posted an answer :-) — skuro, Aug 07 '11 at 02:46

score 4 · Accepted Answer · answered Aug 06 '11 at 21:53

Your Clojure definition of tag quotes everything in the attribute map, while the common lisp version quotes only the names. That's the immediate source of your problems - if you just dropped the ' in front of your vector/map, and then fiddled with the map to quote the first element, you'd probably be fine.

However, while porting may be a good exercise, this code is not written in The Clojure Way: the printing is a nasty ucky side effect that makes it hard to use print-tag to do anything meaningful; returning a string instead would be much nicer.

(defmacro tag [name attrs & body]
  `(str "<" 
        (clojure.string/join " "
                             ['~name
                              ~@(for [[name val] (partition 2 attrs)]
                                  `(str '~name "=\"" ~val "\""))])
        ">"
        ~@body
        "</" '~name ">"))

user> (tag head [foo (+ 1 2)] "TEST" (tag sample []))
"<head foo=\"3\">TEST<sample></sample></head>"

Of course, since order doesn't matter, using a map instead of a vector is nicer for the attributes. That would also mean you could drop the (partition 2...), since a sequential view of a map comes out as pairs already.

And once we've gotten this far, it turns out that there are already plenty of ways to represent XML as Clojure data structures, so I would never use my above code in a real application. If you want to do XML for real, check out any of Hiccup, prxml, or data.xml.

Yeah, I agree it would be much better to use a map. Also using keywords as suggested by Hamza Yerlikaya would be an improvement. I'm not convinced about returning a string - I would actually rather it printed straight to a stream (although using print isn't the right way either). In the end though, I was just trying to understand clojure macros and how they compared to lisp. — Adrian Mouat, Aug 06 '11 at 22:23
Thanks for those links btw. prxml seems to be this approach done properly. One of this nice things about clojure is that it's easy to read and learn from other people's code. — Adrian Mouat, Aug 08 '11 at 08:20
I'm not sure about "proper" - prxml is the most side-effectful of my suggestions, and as part of old contrib is deprecated. data.xml is the future, and should contain all of prxml's features in a more flexible package. — amalloy, Aug 08 '11 at 09:30
Yeah, I meant "proper" in the sense of doing things in roughly the same style as my code but in more idiomatic clojure. — Adrian Mouat, Aug 12 '11 at 08:17

score 0 · Answer 2 · answered Aug 06 '11 at 18:49

I might be missing something but is there a particular reason you quoted blue and big but not color and size, you also quoted in the macro the vector so stuff inside it won't get evaluated, if you drop the quote around the vector and also quote color and big you get what you want,


(defmacro tag [tname atts & body]
  `(do (print-tag '~tname [~@(map (fn [[h# t#]] [h# t#]) (pair atts))] nil)
       ~@body
       (print-tag '~tname nil true)))

(tag mytag ['color 'blue 'size 'big])

<mytag color="blue" size="big"><\mytag>nil

Just for the record instead of symbols using keywords would be more idiomatic clojure for this.

The idea is that attribute names are rarely calculated but their values are e.g. (tag rectangle [height (+ 3 4)]). Not requiring the quote before the attribute name is just a little more concise. — Adrian Mouat, Aug 06 '11 at 18:53

Adrian Mouat · Answer 3 · 2011-08-12T08:18:53.923

0

For the sake of completeness, what I wanted turned out to be:

(defmacro tag [tname atts & body]
  `(do (print-tag '~tname [~@(map (fn [[h# t#]] [`'~h# t#]) (pair atts))] nil)
     ~@body
     (print-tag '~tname nil true)))

edited Aug 12 '11 at 08:18

answered Aug 06 '11 at 22:20

Adrian Mouat

44,585
16
110
102

That won't compile, so I doubt it. Your `\`'~` trick belongs on the *second* instance of `h#`, not the first. – amalloy Aug 06 '11 at 22:35
True. That's weird, I thought I cut and pasted it... Fixed. – Adrian Mouat Aug 12 '11 at 08:18

Evaluating macro arguments in clojure

3 Answers3