Someone's very happy to have authored Clojure's for special form.
(Clojure is simply my lisp of choice. This could be just as easily implemented in elisp, which does not have this built in.)
[edit] For those interested, here's an elisp version: https://gist.github.com/4430934
But everyone should get an opportunity to see what you can do with things like macros, how useful list comprehensions are in general, and how a homoiconic language can make the simple things slightly less intuitive but the hard things vastly more tractable. I certainly have no business in detracting from your enjoyment of Clojure, so please don't allow me to.
Instead of being snarky may I offer some constructive criticism:
1) You don't mention the Clojure `for` special form, which is a built in list comprehension. 2) There's a significant amount baked into Clojure's `for` special form. How does it compare to your macro? After reviewing the macro again I think you'll find there's some differing behaviors over when members of seqs are realized and bound between your implementation and that in clojure.core. 3) I think reflecting on what the real power here is: that you are able to dictate the hows and whys of evaluation at what time, and discussing that matter, can make more salient the power of LISPs.
Please do continue to enjoy what you are building and what you learn, and don't let the jaded musings of crotchety old men like me get in your way!
All of this actually fell out of a desire to better understand Clojure's `for`, which is a piece of code I would have run away from not too long ago. (Earlier versions of this post made significant mention of `for` and its implementation; that it was totally stricken from the final version was, I think, an unfortunate product of editing.)
I'll certainly think more on your second and third points.
Mentioning that there is a `for` form might be nice, just so it's clear that you don't have to do (something like) this in order to do list comprehension in Clojure. Kind of disagree with aredington's 2nd and 3rd points though. Those might be fine things to write some stuff about, but I don't know that that post really needs them.
Like, I don't think every post on macro stuff must deal with "macros and evaluation". It's an interesting topic and all, but as it is I like that the post is more like, here's a macro and look how we can use it to turn code like this into code like that. Without getting into every topic that that touches on.
Minor nit: `for` is a macro in the clojure.core namespace, not a special form. Special forms in Clojure are these: http://clojure.org/special_forms
Having said that, there is probably some educational value in writing out what a special form would look like if it was not a special form, so in that regard, yes, this is interesting to look at.