(let ((var1 1)
      (var2 2)
      ...
      (varn n))
  body)

(foo ((fn1 arg1)
      (fn2 arg2)
      ...
      (fnn argn))
  body)

(progn
  (funcall fn1 arg1)
  (funcall fn2 arg2)
  ...
  (funcall fnn argn)
  body)

(defmacro foo ((&rest call-forms) &body body)
  ...)

(defmacro foo ((single-fn single-arg) &body body)
  ...)

(defmacro foo ((&rest (fn arg)) &body body) ; 无效的语法
  ...)

(defmacro funcall-macro (pairs &body body)
  (handler-case `(progn ,@(mapcar (lambda (pair)
                                    (destructuring-bind (fname arg) pair
                                      (list 'funcall fname arg)))
                                  pairs)
                   ,@body)
    (error (e) (error (format nil "~a~%~" e)))))

(macroexpand-1 '(funcall-macro ((f1 a1)
                              (f2 a2)
                              (fn an))
                         (b1)
                         (b2)
                         (bn)))
(PROGN (FUNCALL F1 A1) (FUNCALL F2 A2) (FUNCALL FN AN) (B1) (B2) (BN))
T

另一种处理这个问题的有趣方法是编写一个宏，它检查*一个*对，并扩展成一个使用相同宏来检查其余部分的形式。做到这一点的一种自然方式是通过模式匹配，这个示例使用了 [`destructuring-match`](https://tfeb.github.io/dsm/) 来实现这一点，因为它专门设计用于以这种方式处理宏形式。
(defmacro foo (clauses &body forms)
  (destructuring-match clauses
    (()
     `(progn ,@forms))
    (((f a) &rest more)
     `(progn
        (funcall ,f ,a)
        (foo ,more ,@forms)))
    (otherwise
     (error "这到底是什么？"))))
现在 `(foo ((a 1) (b 2)) x)` 将会扩展成
(progn
  (funcall a 1)
  (progn
    (funcall b 2)
    (progn x)))
这与你想要的等价。无需担心所有嵌套的 `progn`：编译器会处理这些。
如果 `(foo () ...)` 不应该是合法的，那么你需要像这样：
(defmacro foo (clauses &body forms)
  (destructuring-match clauses
    (((f a))
     `(progn
        (funcall ,f ,a)
        ,@forms))
    (((f a) &rest more)
     `(progn
        (funcall ,f ,a)
        (foo ,more ,@forms)))
    (otherwise
     (error "这到底是什么？"))))
---
你还可以将 `destructuring-match` 用作更灵活但可能较慢的 `destructuring-bind`。特别是，你可以实现另一种解决方案，而不必担心捕获错误，如果你想要自己的错误消息或条件：
(defmacro foo (clauses &body forms)
  `(progn
     ,@(mapcar (lambda (clause)
                 (destructuring-match clause
                   ((f a)
                    `(funcall ,f ,a))
                   (otherwise
                    (error "这到底是什么？"))))
               clauses)
     ,@forms))
使用任一种方法，你当然可以支持更灵活的语法，因此你可以像 `let` 做的那样有一些东西（尽管我认为对于这个特定的宏来说，这可能很难做到）。
<details>
<summary>英文:</summary>
One other interesting way to deal with this problem is to write a macro which checks *one* pair and then expands into a form which uses the same macro to check the rest.  A natural way to do this is by pattern matching, and this example uses [`destructuring-match`](https://tfeb.github.io/dsm/) to do this, as it was specifically designed for processing macro forms in this way.

Now `(foo ((a 1) (b 2)) x)` will expand into

Which is equivalent to what you want.  There's no need to worry about all the nested `progn`s: the compiler will deal with those. 
If `(foo () ...)` should not be legal, then you need something like this:

---
You can also use `destructuring-match` as a more flexible but probably slower `destructuring-bind`.  In particular you can implement one of the other solutions without the annoyance of having to catch the error if you want your own error message or condition:

Using either approach you can support more flexible syntax of course, so you could have something like what `let` does (although this would be hard to get right for this specific macro I think).
</details>