On this blog post aphyr (who is a brilliant programmer) states:Clojure macros come with some important restrictions. Because theyre expanded prior to evaluation, macros are invisible to functions. They cant be composed functionallyyou cant (map or ...), for instance.The classic example of this is:(reduce and [true true false true]);RuntimeExceptionYet we can write:(reduce #(and %1 %2) [true true false true]);falseIs 'macros don't compose' a valid claim? Surely the only  valid point is that macros are not first class functions and shouldn't be treated as such. 
Is it fair to say that macros don't compose?
clojure;composition;macros
I think this depends on what you mean by compose. I would say that it's mostly true but can be taken too far.First, note that in the quote you cited aphyr didn't say macros don't compose; the phrase was can't be composed functionally. That more limited claim is indisputably true. Macros in Clojure aren't values[1]. They can't be passed as arguments to other functions or macros, can't be returned as the result of computations, and can't be stored in data structures.There are, of course, ways to work around these limitations. Besides your #(and %1 %2) example, there's a sense in which the code below represents composition.(ns some.macros  (:refer-clojure :exclude [when when-not]))(defmacro when [test & body]  `(cond ~test (do ~@body)))(defmacro when-not [test & body]  `(when (not ~test) ~@body))I intentionally used cond rather than if in the definition of when because cond is itself a macro.But, back to the larger point, #(and %1 %2) isn't really an argument that macros compose, it's an argument that you can use macros within functions. And, because we have many powerful ways of working with functions, this is generally the best way to go. Use macros (when functions aren't appropriate) to abstract away boilerplate, repetitive code, but, when possible, ultimately expose as much of your API as possible as functions so that they can be stored in hash-maps, mapped over sequences of widgets, negated with complement, juxtaposed with juxt, and so on.[1] It would be difficult for it to be otherwise. Imagine if macros were values and could be passed as arguments to functions. How could you compile code that used such a macro, given that its expansion wouldn't be known until runtime (and could vary between invokations of the function)?AddendumAs a point of interest, consider that macros are functions, they're just treated specially by the compiler.Check this out:some.macros> (defn when [&form &env test & body]               `(cond ~test (do ~@body)))#<Var@1a37b98:  #<macros$eval7806$when__7807 some.macros$eval7806$when__7807@d1cf9c>>some.macros> (when nil nil true 1 2)(clojure.core/cond true (do 1 2))some.macros> (. #'when (setMacro))nilsome.macros> (when true 1 2)2This is, in fact, exactly how defmacro works. (See here for an explanation of the &form and &env pseudo-arguments).