lisp中的递归跟踪。。。我需要一些建议

有没有人能抽出一点时间来帮助我理解为什么在Lisp中的这个小函数中，这个值始终为真

(defun fob (n)
   (if (= n 10)
      'true
      (fob (+ n 1))))

不断对跟踪进行评估，以：

  0: (FOB 5)                                                                                                                                                                                  

    1: (FOB 6)                                                                                                                                                                                

      2: (FOB 7)                                                                                                                                                                              

        3: (FOB 8)                                                                                                                                                                            

          4: (FOB 9)                                                                                                                                                                          

            5: (FOB 10)                                                                                                                                                                       

            5: FOB returned TRUE                                                                                                                                                              

          4: FOB returned TRUE                                                                                                                                                                

        3: FOB returned TRUE                                                                                                                                                                  

      2: FOB returned TRUE                                                                                                                                                                    

    1: FOB returned TRUE                                                                                                                                                                      

  0: FOB returned TRUE 

---

我不明白为什么它会返回“true”，尽管6显然不等于10。我只是看错了痕迹吗？任何帮助都将不胜感激。：）

如注释中所述，递归有两个组成部分：基本情况（不进行递归调用的条件）和递归情况。跳过基本情况的递归函数可以通过递归情况返回值

在您的示例中，每次调用向

n

添加1将得到

n=10

的基本情况（假设

n

从

10

开始，您将有无限递归，因为基本情况无法访问）。当调用到达

n=10

时，基本大小写将返回true，该值将一直传回调用堆栈。对于函数，只有两种可能的结果：无限递归或返回true

---

这解释了为什么对于

n=5

，所有函数都返回true；尽管它们的基本情况在

n=10

之前是不正确的，但子调用的结果是。

如注释中所述，递归有两个组成部分：基本情况（不进行递归调用的条件）和递归情况。跳过基本情况的递归函数可以通过递归情况返回值

在您的示例中，每次调用向

n

添加1将得到

n=10

的基本情况（假设

n

从

10

开始，您将有无限递归，因为基本情况无法访问）。当调用到达

n=10

时，基本大小写将返回true，该值将一直传回调用堆栈。对于函数，只有两种可能的结果：无限递归或返回true

---

这解释了为什么对于

n=5

，所有函数都返回true；尽管它们的基本情况直到

n=10

才为真，但子调用的结果是。

它递归添加1，直到

n

与10匹配，在该点返回真值，以备份递归调用。试着用大于10的值调用它，看看会发生什么。所以基本上我读错了跟踪。。。如果我理解正确的话，它不会向递归调用发送true，因为在每次递归调用中，它的求值为true，只是因为它在n=10时的求值为true，它才将整个过程表示为true？而且，用大于10的数字来呼叫它会使它像我预料的那样失控。我试图理解递归，并使我知道的非常简单的函数的计算结果为真，以帮助理解发生了什么，跟踪的输出让我感到困惑。调用在两种情况下返回true：（1）调用本身内部的

n=10

，或者（2）如果

n！=10

，再次使用

n+1

调用函数，并返回结果。如果某个子调用返回true（即某个子调用中的

n=10

），则父函数也将返回true。ook。。。我想我现在明白了。非常感谢您抽出时间。非常感谢。它递归添加1，直到

n

与10匹配，在该点上返回true以备份递归调用。试着用大于10的值调用它，看看会发生什么。所以基本上我读错了跟踪。。。如果我理解正确的话，它不会向递归调用发送true，因为在每次递归调用中，它的求值为true，只是因为它在n=10时的求值为true，它才将整个过程表示为true？而且，用大于10的数字来呼叫它会使它像我预料的那样失控。我试图理解递归，并使我知道的非常简单的函数的计算结果为真，以帮助理解发生了什么，跟踪的输出让我感到困惑。调用在两种情况下返回true：（1）调用本身内部的

n=10

，或者（2）如果

n！=10

，再次使用

n+1

调用函数，并返回结果。如果某个子调用返回true（即某个子调用中的

n=10

），则父函数也将返回true。ook。。。我想我现在明白了。非常感谢您抽出时间。非常感谢。