返回到 Lisp 中递归函数的顶层调用

Question

我有一个递归函数，它需要递归直到找到某个结果。然而，在我第一次递归调用之后，在我的函数体中，我可能会进行一些其他计算或可能再次递归。但是，如果我递归并找到我正在寻找的结果，那么我想停止我一直在做的任何递归并返回该结果以避免进行不必要的计算。

在正常的递归调用中，一旦您到达“基本情况”，该情况将返回给调用的函数，然后将其返回给调用它的函数，依此类推。我想知道如何返回到第一次调用该函数，而不必为所有这些中间步骤返回一些东西。

对于我的基本递归，我可以编写如下函数：

(defun recurse (x)
   (if (= x 10)
       (return-from recurse x)
       (progn (recurse (+ x 1)) (print "Recursed!")))))
(recurse 1)

写它是为了说明我在递归调用后运行更多计算的函数的意思。而且，正如所写，这甚至不会返回我感兴趣的值，因为我在返回我关心的值之后进行了一些打印。 （注意：return-from 命令在这里是无关紧要的，因为我可以在它的位置写上“x”。在下面的第二个示例中，当我尝试返回顶级递归时，它只是为了绘制相似之处。）

现在，如果我想放弃所有那些额外的“递归！”我可以将所有内容都封装在一个块中，然后返回到该块：

编辑：这是我原始示例的函数包装器。这个例子现在应该更清楚了。

(defun recurse-to-top (start)
  (block top-level
    (labels ((recurse (x)
               (if (= x 10)
                   (return-from top-level x)
                   (progn (recurse (+ x 1)) (print "Recursed!")))))
      (recurse start))))

继续运行这个块，直到“找到”10，然后从顶层块返回，没有多余的打印，就像我想要的那样。但是，这似乎是获得此功能的一种非常笨拙的方式。我想知道是否有获得这种行为的标准或“最佳”方式。

Answer 1

你想要某种非本地出口。有几个选择：return-from、go、throw、signal。

也许这有一些变化？

(defun recurse (x &optional (tag 'done))
  (catch tag
    (when (= x 10)
      (throw 'done x))
    (recurse (1+ x) nil)
    (print "Cursed!")))

我相信它会做你想做的事，尽管可能会有很多不必要的捕捉。

与 Lisp 一样，您可以想象有一种完美的语言可以解决您的问题，并用该语言编写程序。例如。像

(defun recurse (x)
  (top-level-block recurse
    (when (= x 10)
      (return-from-top-level recurse x))
    (recurse (1+ x))
    (print "Cursed!")))

那么只需简单的编程即可实现新的宏top-level-block 和return-from-top-level。

不完善的示例代码如下：

(defmacro top-level-block (name &body body)
  `(if (boundp ',name)
       (progn ,@body)
       (catch ',name
         (let ((,name t))
           (declare (special ,name))
           ,@body))))

(defmacro return-from-top-level (name value)
  `(throw ',name ,value))

Answer 2

DEFUN 已经建立了一个词法块：

(defun recurse (start)
  (labels ((recurse-aux (x)
             (case x
               (10 (return-from recurse x))
               (15 x)
               (otherwise
                 (recurse-aux (+ x 1))
                 (print "Recursed!")))))
    (recurse-aux start)))

较旧的是使用CATCH 和THROW，这是一个更动态的构造，因此允许跨函数退出：

(defun recurse (start)
  (catch 'recurse-exit
    (recurse-aux start)))

(defun recurse-aux  (x)
  (case x
    (10 (throw 'recurse-exit x))
    (15 x)
    (otherwise
     (recurse-aux (+ x 1))
     (print "Recursed!")))))
      (recurse-aux start))))

正如 Lars 所提到的，还有更多方法可以像这样对控制流进行编程。