On Wed, Dec 15, 2010 at 11:22 AM, Poojan <poojanshah2...@gmail.com> wrote: > I was trying to print out a list of symbols and I was wondering if I > could remove the quotes. > > (def process-print-list > (fn [a-list] > (cond (empty? a-list) 'false > (list? a-list) (let [a a-list] (println (first a)) (process-print- > list (rest a) )) > :else (process-print-list (rest a-list) )))) > > the list is ('x 'y 'z)) > > with the following output: > > (quote x) > (quote y) > (quote z)
I'm not sure why you have the let in there. It's also usually better to work on generic sequences than specifically on lists -- I almost never use list? in production code. Indeed yours still traverses non-list seqs but doesn't print anything for them. As for the output, I don't see that happening with the code you posted. I *do* see that happening if ('x 'y 'z) is being passed to a macro that then calls process-print-list itself, at macroexpansion time, rather than emitting code that calls process-print-list. If you are passing symbols to a macro you usually DON'T want to quote them -- i.e. (my-macro (x y z)) rather than (my-macro ('x 'y 'z)) is probably the sort of change you want to make. Macros don't evaluate their arguments, they just plop them into their output verbatim (or can even traverse their s-expression structure for various purposes) and the output gets evaluated later. (defn foo [] (my-macro ('x 'y 'z))) (foo) When the defn form is evaluated, my-macro is called and expands into something. At this time the list ('x 'y 'z) is not evaluated; it likely just ends up in the macro output (the final code for the function foo) somewhere. When foo is called later on, it gets evaluated. If the macro is printing its argument via process-print-list (say as a debugging tool), the argument really is ((quote x) (quote y) (quote z)); 'x is just shorthand for (quote x). (You might want to look into using macroexpand-1 as a debugging tool, too.) When the function foo evaluates the expansion, it will end up with the actual symbol objects x, y, and z, also. If you have something like (defn foo [x y z] (my-macro ('x 'y 'z))) (foo 1 2 3) the arguments to foo will end up unused (unless the macro plays around with &env and its quoted argument). Again you probably then want (defn foo [x y z] (my-macro (x y z))) (foo 1 2 3) whereupon in my-macro the argument will actually be a list of three symbols, x, y, and z, which will get plopped into the output somewhere, and when foo is called the evaluation of those symbols will yield the function's three arguments. -- You received this message because you are subscribed to the Google Groups "Clojure" group. To post to this group, send email to clojure@googlegroups.com Note that posts from new members are moderated - please be patient with your first post. To unsubscribe from this group, send email to clojure+unsubscr...@googlegroups.com For more options, visit this group at http://groups.google.com/group/clojure?hl=en