从一对到 lambda 演算/方案中的列表

Question

我正在学习一些关于 lambda 微积分（非常简洁）的知识，并在方案中定义了以下如何完成一对：

; PAIR
; λabf.fab
(define PAIR (lambda (a) (lambda (b) (lambda (f) ((f a) b)))))
(define mypair ((PAIR 1) 2))

; FIRST
; λab.a
(define FIRST (lambda (a) (lambda (b) a)))

; SECOND
; λab.b
(define SECOND (lambda (a) (lambda (b) b)))

(display "First is: ")     (display (mypair FIRST))
(display " | Second is: ") (display (mypair SECOND))

First is: 1 | Second is: 2

如何进一步抽象这一点以创建列表的数据结构，例如，制作类似[1 2 3 4 5]而不是[2 3]的东西？

我自己能做的最好的事情就是对这些进行硬编码，例如，五个：

(define five (
    (PAIR 1) (
      (PAIR 2) (
        (PAIR 3) (
          (PAIR 4) 5)))))

(display (five FIRST)) (display ((five SECOND) FIRST)) (display (((five SECOND) SECOND) FIRST)) (display ((((five SECOND) SECOND) SECOND) FIRST)) (display ((((five SECOND) SECOND) SECOND) SECOND))

12345

有没有更“通用”的解决方案？

Answer 1

正常的 LISP 列表不是[1 2 3] ，而是(1. (2. (3. ()))) 。 它们是用(cons 1 (cons 2 (cons 3 '())))创建的，因此 lambda 演算中的确切相等列表将是((PAIR 1) ((PAIR 2) ((PAIR 3)...)))

现在标准的 lisp 实现通常打印(1 2 3) ，但这是打印机完成的一些时髦的魔法。 它的规则是，如果cdr是一个列表，您可以省略点和一组括号。 当您使用 lambda 微积分到 model 数据时，REPL 将始终显示 lambda/closure 对象，因此您需要了解结构并显示对应的可视化的实用程序函数。 这不是 lambda 演算的标准，因为它可以满足公理：

(car (cons a b)) ; ==> a
(cdr (cons a b)) ; ==> b

list是一个辅助 function，它连接cons 。 您确实可以为配对做类似的事情，但它不是 lambda 演算的一部分：

(define TRUE (lambda (p) (lambda (q) p)))
(define NIL (lambda (x) TRUE))

(define (ch-list . args)
  (let helper ((lst (reverse args)) (result NIL))
    (if (null? lst)
        result
        (helper (cdr lst)
                ((PAIR (car lst)) result)))))

Answer 2

正如西尔韦斯特所说。 列表不是 arrays，它们是 conses 链，以特殊的nil或() object 结尾。 这意味着要构建这样的东西，你需要cons和这个特殊的 object。

我在 Racket 中实现了一种玩具语言，称为“oa”（一个参数），几分钟前，您可以在此处找到。 在其最纯粹的变体中，函数的语法是，例如(λ xx) ：参数周围没有括号，因为为什么会有？ 也有define给事物命名，但仅此而已。 这是该语言中 conses 的实现：

(define true (λ x (λ y x)))
(define false (λ x (λ y y)))

(define cons (λ h (λ t (λ s ((s h) t)))))
(define car (λ l (l true)))
(define cdr (λ l (l false)))
(define nil (λ l true))
(define null? (λ l (l (λ h (λ t false)))))

方便（但也很烦人），oa 使用普通的 Racket 阅读器，因此您可以阅读数字，即使它们在语言中没有语义。 所以，例如

> (cdr ((cons 1) 1))
1

比如说，制作一个元素的三元素列表：

(define three-elt
  (λ e
    ((cons e)
     ((cons e)
      ((cons e)
       nil)))))

> (three-elt 1)
#<λ>
> (car (three-elt 1))
1
> (cdr (cdr (cdr (three-elt 1))))
{nil}: (λ l true)

（有一些特殊的，片状的，魔法可以让它打印在最后一种情况下define为 d 的事物的名称。）

给定zero的定义， zero? , succ和pred （后继和前任），以及一个有条件的 function, cond ，看起来像(((cond test) if-true) if-false) ，然后您可以编写nth的脏版本：

(define nth
  (λ n (λ c
         (((cond (zero? n))
           (car c))
          ((nth (pred n)) (cdr c))))))

这很脏，因为它使用nth free，但您可以使用组合器修复它：我喜欢 U，所以：

(define U
  ;; The U combinator
  (λ f (f f)))

(define nth
  (U (λ t
       (λ n
         (λ c
           (((cond (zero? n))
             (car c))
            (((U t) (pred n)) (cdr c))))))))

使用其中任何一个：

> ((nth (succ zero)) ((cons true) ((cons false) nil)))
{false}: (λ x (λ y y))
> ((nth zero) ((cons true) ((cons false) nil)))
{true}: (λ x (λ y x))

我不认为你能做的是这样实现list ，因为即使你添加了特殊的魔法来表达像list这样的 nospread 函数，你也需要将它的所有 arguments 变成一个列表。 但我可能错了。

以上所有函数都存在于oa中的examples/lc.rkt中。