&gt; <i>because ordinary Lisp functions are limited in how they can work with &quot;context-dependent code fragments&quot; passed as arguments. Rebol attacks this problem by making bindings of individual symbols &quot;travel along&quot; with their code fragments. The result is that many cases requiring macros in Lisp can be written as ordinary Rebol functions.</i><p>Bzzt, no.  &quot;Context dependent code fragments&quot; are &quot;lambdas&quot; in mainstream Lisp dialects, which carry the environment (i.e. bindings of symbols) via lexical closure.<p>Now, indeed, one of the uses of macros is to provide some (usually mild) sprinkling of syntactic sugar to conceal lambda syntax.<p>&gt; <i>But packing code into a [functional&#x2F;lambda] &quot;black box&quot; creates barriers to transformations that are a big part of the appeal of using a homoiconic language.</i><p>The history of Lisp has recorded considerable experience with the FEXPR approach to language extension. Lispers had worked out decades ago that this largely sucks, and so interest in FEXPRs waned. They do not appear as a feature in Scheme or Common Lisp, and it&#x27;s not for lack of knowledge or experience.<p>Essentially, Lisp performed a &quot;Rebol-ectomy&quot; on its semantics by the end of the 1960&#x27;s or thereabouts.<p>Anyway, to understand macros fully, you have to step out of the role of language user and put on a &quot;compleat hacker&quot; hat. Suppose you have complete control at your disposal: you can hack any aspect of the language, as deeply in the implementation as you want. You can add new features that cannot be made out of anything which is already there. In spite of that control, you still want macros. Because macros let you separate the concern of designing the low-level abstractions that are the most convenient for a given feature, and a user interface to them which is nice for the user. (Without macros, you face the annoyance of having to extend the repertoire of special operators, even in situations when it is obvious that these new ones should just expand to some other syntax in terms of functions, plus the old ones).<p>If I&#x27;m extending a language deeply at the implementation level, I&#x27;m doing something that can&#x27;t be done with macros or functions anything else; yet macros help in a specific way that other things don&#x27;t. I still want them in spite of having total control. If I add non-strict evaluation into the language core, I want macros. If I add continuations, I want macros. If I add functional reactive programming, I still want macros, etc.  Macros mean I don&#x27;t have to go into the compiler, or code walker or elsewhere and add new cases to handle special operators. I don&#x27;t have to go into the grammar of some parser generator to add the syntax, where the parser action is just &quot;construct a node for this new syntax, exactly like some equivalent longer expression would generate&quot;.<p>(If you say you already have all the syntax you would ever need and everything else is just done with that syntax, then you are not wearing the &quot;compleat hacker&quot; hat.)