Little Schemer：编写只支持长度≤2的列表的函数

Question

在The little schemer一书中，我们发现这个函数只支持长度小于或等于1的列表：

 (((lambda (mk-length)                                  ; A.
      (mk-length mk-length))
  (lambda (mk-length)
      (lambda (l)
          (cond
              ((null? l ) 0)
              (else (add1 ((mk-length  eternity ) (cdr l))))))))
 '(1))

我想一步一步学习，想写一个类似的函数，只支持长度小于等于2的列表。

请不要通过提供以下代码来回答这个问题：

(((lambda (mk-length)                                   ; B.
      (mk-length mk-length))
  (lambda (mk-length)
      (lambda (l)
          (cond
              ((null? l) 0 )
              (else (add1((mk-length mk-length) (cdr l))))))))
 '(a b c d))

因为这个函数支持任意长度。

而且我已经知道如何编写这样的函数：

(((lambda (mk-length)                                   ; C.
      (mk-length
          (mk-length (mk-length eternity))))
  (lambda (length)
      (lambda (l)
          (cond
              ((null? l) 0)
              (else (add1 (length (cdr l))))))))
 '(1 2)) ;;

实现我的目标。但是这段代码距离第一个sn-p还不止一步。

也许，我不应该改变：

(lambda (mk-length)                                     ; D.
      (mk-length mk-length)

Answer 1

TL;DR:(mk-length <b>A</b>)（在cond 表单内）计算适用于长度为0的列表的length函数em> 并将使用(<b>A</b> A) 计算length 函数，该函数将用于处理参数列表的尾部（即(cdr ...) 的结果）。

---

您的第一个代码 sn-p (;A.) 仅适用于长度为 0 和 1 的列表。为了使其也适用于 2，替换

                               (mk-length <b>eternity</b>)               ; length≤1

与

                               (mk-length   ; (2)                 ; length≤2
                                  (lambda (x) (mk-length eternity)))

有效。

（注意：(mk-length eternity) 本身计算了length≤0，但整体函数变成了length≤1；这个是所有进一步的length≤i cmets 所指的。）

仔细观察

     (((lambda (mk-length)
          (mk-length mk-length))            
      (lambda (mk-length)                   ; (1)
          (lambda (l)                       
              (cond
                  ((null? l ) 0)
                  (else (add1 ((mk-length   ; (2)                 ; length≤2
                                  (lambda (x) (mk-length eternity)) )
                               (cdr l))))))))
     '(1 2))

我们可以看到;(2)处的(mk-length <b>...</b>)的结果用于处理(cdr l)，而;(2)处的argument到mk-length将替换mk-length在处理(cddr l)时的那个调用中。

如果使用(mk-length <b>eternity</b>)（如在您的第一个代码中），(cdr l) 可以正常处理，但((<b>eternity</b> eternity) (cddr l)) 自然会失败。

如果使用(mk-length <b>(lambda (x) (mk-length eternity))</b>)，则(cdr l) 处理正常，然后(<b>(lambda (x) (mk-length eternity))</b> (lambda (x) (mk-length eternity))) = (mk-length <b>eternity</b>) 用于处理(cddr l)，这也正常（因此，长度2 处理正确），并且然后((<b>eternity</b> eternity) (cdddr l)) 自然会失败（长度为 3 及以上）。

因此要处理最多三个元素的列表，

                              ((mk-length   ; (2)                 ; length≤3
                                  (lambda (x) (mk-length 
                                                (lambda (x) (mk-length eternity)))) )

可以使用：

    (define (eternity x) (- 1))    ; to get an error instead of looping

    (((lambda (mk-length)
          (mk-length mk-length))
      (lambda (mk-length)
          (lambda (l)
              (cond
                  ((null? l ) 0)
                  (else (add1 ((mk-length   ; (2)                 ; length≤3
                                  (lambda (x) (mk-length
                                               (lambda (x) (mk-length eternity)))) )
                               (cdr l))))))))

      '(1 2 3))        ; => 3

    ; ...........
    ; '(1 2 3 4))      ; => **error**

正如您正确推测的那样，这是使用过程中的中间步骤

                     (mk-length <b>(lambda (x) (mk-length x))</b>)   ; (2)       ; length≤∞

依次将列表的下一个元素处理成

                     ((lambda (x) (mk-length x)) (lambda (x) (mk-length x)))
    =
                     (mk-length (lambda (x) (mk-length x)))

因此适用于每个列表，无论其长度是多少。

通过 eta 转换，这只是 (mk-length mk-length)。

Answer 2

Lisp 中的列表（Scheme、Common Lisp 等）由 cons 单元和一个特殊的（空列表）构成。也就是说，只要你有一个列表，它就是 either：

• 空列表()
• cons 单元格（也称为对），其中对的 car 是列表的第一个元素，而对的 cdr 是其余的列表。

因为有两种类型的列表，所以列表上的递归算法通常只回答两个问题：

• 空列表的结果是什么？
• 列表其余部分的结果是什么？如何变成整个列表的结果？

对于长度，这意味着：

• 空列表长度为0。
• 当列表的rest长度为n时，整个列表的长度为n + 1。

The Little Schemer 中提出的解决方案类型首先开发了一个解决第一种情况的解决方案，这意味着它适用于长度 ≤0 的列表。只要您有一个可以（正确）处理这两种情况的解决方案，您就有一个适用于任何长度列表的解决方案。没有真正的增量解决方案可以扩展该函数以适用于长度为 ≤2 的列表。

你可以，我想，做这样的事情：

 (((lambda (mk-length)
      (mk-length mk-length))
  (lambda (mk-length)
      (lambda (l)
          (cond
              ((null? l ) 0)
              (else 1)))))

这适用于长度为 0 的列表和长度为 1 的列表，并且对于所有其他列表都不正确，但对于所有其他列表它将返回 1。除非您更改递归的结构，否则我认为这确实是您能做的最好的事情。如果你愿意改变递归的结构，你可以这样做：

 (((lambda (mk-length)
      (mk-length mk-length))
  (lambda (mk-length)
      (lambda (l)
          (cond
              ((null? l) 0)
              ((null? (cdr l)) 1)
              (else (add1 ((mk-length  eternity ) (cdr l))))))))

但是您真的不应该采用这种方法，因为现在您正在处理三种不同情况下的列表，而不是两种，这（几乎）从来都不是您想要做的。

对 Python 的翻译

这种思维可以用 python 或者其他的过程语言改写吗？在递归中仍然很难想象一个自动创造的乐趣。

同样的原理也适用于 Python 或任何支持高阶函数的语言。在 Python 中，本地定义函数然后调用它更习惯，而不是直接调用 lambda 表达式，所以这对你来说可能更具可读性：

def length(l):
    def driver(recurse):
        "Returns the result of calling `recurse` with itself."
        return recurse(recurse);
    def zeroForEmptyListOrElseOnePlusRecurse(recurse):
        """Returns a function that returns 0 if its input is the
        empty list, or else returns one plus whatever calling 
        `recurse(recurse)` with the tail of the list returns."""
        def length(l):
            """Returns 0 if l is the empty list, and one plus
            the results of `(recurse(recurse))(l)` otherwise."""
            if l == []:
                return 0;
            else:
                _, *rest = l
                return 1+(recurse(recurse))(rest)
        return length
    return (driver(zeroForEmptyListOrElseOnePlusRecurse))(l)

print(length([1,2,3])) # 3
print(length([1,2]))   # 2
print(length([1]))     # 1
print(length([]))      # 0