Lisp宏允许您决定何时(如果有的话)对任何部分或表达式求值。举个简单的例子，想想C语言:

expr1 && expr2 && expr3 ...

它说的是:计算expr1，并且，如果它是正确的，计算expr2，等等。

现在试着把这个&&变成一个函数…没错，你不能。像这样调用:

and(expr1, expr2, expr3)

将在产生答案之前评估所有三个表达式，而不管expr1是否为假!

使用lisp宏，你可以编写如下代码:

(defmacro && (expr1 &rest exprs)
    `(if ,expr1                     ;` Warning: I have not tested
         (&& ,@exprs)               ;   this and might be wrong!
         nil))

现在你有一个&&，你可以像函数一样调用它，它不会计算你传递给它的任何表单，除非它们都为真。

要了解这是如何有用的，请进行对比:

(&& (very-cheap-operation)
    (very-expensive-operation)
    (operation-with-serious-side-effects))

and:

and(very_cheap_operation(),
    very_expensive_operation(),
    operation_with_serious_side_effects());

你可以用宏做的其他事情是创建新的关键字和/或迷你语言(例如，查看(loop…)宏)，将其他语言集成到lisp中，例如，你可以编写一个宏，让你这样说:

(setvar *rows* (sql select count(*)
                      from some-table
                     where column1 = "Yes"
                       and column2 like "some%string%")

这还没有涉及到Reader宏。

希望这能有所帮助。

While the above all explains what macros are and even have cool examples, I think the key difference between a macro and a normal function is that LISP evaluates all the parameters first before calling the function. With a macro it's the reverse, LISP passes the parameters unevaluated to the macro. For example, if you pass (+ 1 2) to a function, the function will receive the value 3. If you pass this to a macro, it will receive a List( + 1 2). This can be used to do all kinds of incredibly useful stuff.

Adding a new control structure, e.g. loop or the deconstruction of a list Measure the time it takes to execute a function passed in. With a function the parameter would be evaluated before control is passed to the function. With the macro, you can splice your code between the start and stop of your stopwatch. The below has the exact same code in a macro and a function and the output is very different. Note: This is a contrived example and the implementation was chosen so that it is identical to better highlight the difference. (defmacro working-timer (b) (let ( (start (get-universal-time)) (result (eval b))) ;; not splicing here to keep stuff simple ((- (get-universal-time) start)))) (defun my-broken-timer (b) (let ( (start (get-universal-time)) (result (eval b))) ;; doesn't even need eval ((- (get-universal-time) start)))) (working-timer (sleep 10)) => 10 (broken-timer (sleep 10)) => 0

我从通用的lisp烹饪书中得到了这个，我认为它解释了为什么lisp宏是有用的。

宏是一段普通的Lisp代码，它对另一段假定的Lisp代码进行操作，将其翻译成(更接近于)可执行的Lisp。这听起来可能有点复杂，所以让我们举一个简单的例子。假设您想要一个版本的setq，将两个变量设置为相同的值。所以如果你写

(setq2 x y (+ z 3))

当z=8时，x和y都被设为11。(我想不出这有什么用，但这只是一个例子。)

It should be obvious that we can't define setq2 as a function. If x=50 and y=-5, this function would receive the values 50, -5, and 11; it would have no knowledge of what variables were supposed to be set. What we really want to say is, When you (the Lisp system) see (setq2 v1 v2 e), treat it as equivalent to (progn (setq v1 e) (setq v2 e)). Actually, this isn't quite right, but it will do for now. A macro allows us to do precisely this, by specifying a program for transforming the input pattern (setq2 v1 v2 e)" into the output pattern (progn ...)."

如果你觉得这很好，你可以继续读下去: http://cl-cookbook.sourceforge.net/macros.html

由于现有的答案给出了很好的具体例子来解释宏实现了什么以及如何实现的，也许它会帮助收集一些关于为什么宏功能相对于其他语言是一个重要的收获的想法;首先是这些答案，然后是其他地方的一个很棒的答案:

．.． 在C语言中，你必须编写一个自定义的预处理器(这可能是一个足够复杂的C程序)……

—瓦廷

与任何精通c++的人交谈，问他们花了多长时间来学习模板元编程(仍然不是那么强大)所需要的所有模板。

马特·柯蒂斯

．.． 在Java中，你必须破解字节码编织的方法，尽管像AspectJ这样的框架允许你使用不同的方法来做到这一点，但它基本上是一种破解。

——米格尔·平

DOLIST is similar to Perl's foreach or Python's for. Java added a similar kind of loop construct with the "enhanced" for loop in Java 1.5, as part of JSR-201. Notice what a difference macros make. A Lisp programmer who notices a common pattern in their code can write a macro to give themselves a source-level abstraction of that pattern. A Java programmer who notices the same pattern has to convince Sun that this particular abstraction is worth adding to the language. Then Sun has to publish a JSR and convene an industry-wide "expert group" to hash everything out. That process--according to Sun--takes an average of 18 months. After that, the compiler writers all have to go upgrade their compilers to support the new feature. And even once the Java programmer's favorite compiler supports the new version of Java, they probably ''still'' can't use the new feature until they're allowed to break source compatibility with older versions of Java. So an annoyance that Common Lisp programmers can resolve for themselves within five minutes plagues Java programmers for years.

——peter Seibel，在《Practical Common Lisp》中

Lisp宏允许您决定何时(如果有的话)对任何部分或表达式求值。举个简单的例子，想想C语言:

expr1 && expr2 && expr3 ...

它说的是:计算expr1，并且，如果它是正确的，计算expr2，等等。

现在试着把这个&&变成一个函数…没错，你不能。像这样调用:

and(expr1, expr2, expr3)

将在产生答案之前评估所有三个表达式，而不管expr1是否为假!

使用lisp宏，你可以编写如下代码:

(defmacro && (expr1 &rest exprs)
    `(if ,expr1                     ;` Warning: I have not tested
         (&& ,@exprs)               ;   this and might be wrong!
         nil))

现在你有一个&&，你可以像函数一样调用它，它不会计算你传递给它的任何表单，除非它们都为真。

要了解这是如何有用的，请进行对比:

(&& (very-cheap-operation)
    (very-expensive-operation)
    (operation-with-serious-side-effects))

and:

and(very_cheap_operation(),
    very_expensive_operation(),
    operation_with_serious_side_effects());

你可以用宏做的其他事情是创建新的关键字和/或迷你语言(例如，查看(loop…)宏)，将其他语言集成到lisp中，例如，你可以编写一个宏，让你这样说:

(setvar *rows* (sql select count(*)
                      from some-table
                     where column1 = "Yes"
                       and column2 like "some%string%")

这还没有涉及到Reader宏。

希望这能有所帮助。

简而言之，宏用于定义通用Lisp或领域特定语言(dsl)的语言语法扩展。这些语言直接嵌入到现有的Lisp代码中。现在，dsl可以具有与Lisp相似的语法(如Peter Norvig的用于通用Lisp的Prolog解释器)，也可以具有完全不同的语法(例如用于Clojure的中缀符号数学)。

这里有一个更具体的例子:Python在语言中内置了列表推导式。这为常见情况提供了简单的语法。这条线

divisibleByTwo = [x for x in range(10) if x % 2 == 0]

生成一个包含0到9之间所有偶数的列表。在Python 1.5版本中还没有这样的语法;你可以使用类似这样的语句:

divisibleByTwo = []
for x in range( 10 ):
   if x % 2 == 0:
      divisibleByTwo.append( x )

它们在功能上是等价的。让我们暂停怀疑，假设Lisp有一个非常有限的循环宏，它只做迭代，没有简单的方法来做等价的列表推导。

在Lisp中，您可以编写如下代码。我应该指出，这个虚构的例子与Python代码相同，而不是Lisp代码的好例子。

;; the following two functions just make equivalent of Python's range function
;; you can safely ignore them unless you are running this code
(defun range-helper (x)
  (if (= x 0)
      (list x)
      (cons x (range-helper (- x 1)))))

(defun range (x)
  (reverse (range-helper (- x 1))))

;; equivalent to the python example:
;; define a variable
(defvar divisibleByTwo nil)

;; loop from 0 upto and including 9
(loop for x in (range 10)
   ;; test for divisibility by two
   if (= (mod x 2) 0) 
   ;; append to the list
   do (setq divisibleByTwo (append divisibleByTwo (list x))))

在我进一步讨论之前，我应该更好地解释什么是宏。它是一个代码对一个代码执行的转换。也就是说，由解释器(或编译器)读取的一段代码，将代码作为参数，进行操作并返回结果，然后在适当的位置运行。

当然，这需要大量的输入，而且程序员很懒。所以我们可以定义DSL来做列表推导。事实上，我们已经在使用一个宏(循环宏)。

Lisp defines a couple of special syntax forms. The quote (') indicates the next token is a literal. The quasiquote or backtick (`) indicates the next token is a literal with escapes. Escapes are indicated by the comma operator. The literal '(1 2 3) is the equivalent of Python's [1, 2, 3]. You can assign it to another variable or use it in place. You can think of `(1 2 ,x) as the equivalent of Python's [1, 2, x] where x is a variable previously defined. This list notation is part of the magic that goes into macros. The second part is the Lisp reader which intelligently substitutes macros for code but that is best illustrated below:

因此，我们可以定义一个名为lcomp(列表理解的缩写)的宏。它的语法将完全像我们在示例中使用的python [x for x in range(10) if x % 2 == 0] - (lcomp x for x in (range 10) if (= (% x 2) 0)))

(defmacro lcomp (expression for var in list conditional conditional-test)
  ;; create a unique variable name for the result
  (let ((result (gensym)))
    ;; the arguments are really code so we can substitute them 
    ;; store nil in the unique variable name generated above
    `(let ((,result nil))
       ;; var is a variable name
       ;; list is the list literal we are suppose to iterate over
       (loop for ,var in ,list
            ;; conditional is if or unless
            ;; conditional-test is (= (mod x 2) 0) in our examples
            ,conditional ,conditional-test
            ;; and this is the action from the earlier lisp example
            ;; result = result + [x] in python
            do (setq ,result (append ,result (list ,expression))))
           ;; return the result 
       ,result)))

现在我们可以在命令行执行:

CL-USER> (lcomp x for x in (range 10) if (= (mod x 2) 0))
(0 2 4 6 8)

很整洁，是吧?现在还不止于此。你有一个装置，或者画笔，如果你喜欢的话。你可以使用任何你想要的语法。就像Python或c#的语法一样。或者。net的LINQ语法。最终，这就是Lisp吸引人们的地方——极致的灵活性。