关于 mapcon 及其假定等价的问题 (apply #'ncconc (maplist ...)) 使用新分配的列表偶然循环列表

如何解决关于 mapcon 及其假定等价的问题 (apply #'ncconc (maplist ...)) 使用新分配的列表偶然循环列表

Hyperspec 声明 .apply(str) 是（大致？）等价于 mapcon，即“应用函数的结果通过使用 nconc 而不是列表组合成一个列表” .

但是如果这样

(apply #'nconc (maplist ...))

有效，为什么不行

(maplist #'identity '(1 2 3)) ; '((1 2 3) (2 3) (3))
(apply #'nconc '((1 2 3) (2 3) (3)))

也工作？

解决方法

这种关系并不“大致”相同，它的定义完全相同：

(mapcon f x1 ... xn)
  ==  (apply #'nconc (maplist f x1 ... xn))

此外，NCONC 是根据 LAST 和 RPLACD 递归定义的：

(nconc) =>  ()
(nconc nil . lists) ==  (nconc . lists)
(nconc list) =>  list
(nconc list-1 list-2) ==  (progn (rplacd (last list-1) list-2) list-1)
(nconc list-1 list-2 . lists) ==  (nconc (nconc list-1 list-2) . lists)

一个实现可以自由地对此有一个有效的实现，只要它计算相同的结果。但是，由于它被定义为使用 rplacd，它肯定会改变列表（它链接每个中间结果的最后一个 cons 单元的 cdr 槽）。

第 §3.7.1 Modification of Literal Objects 节还说：

如果文字对象被破坏性修改，后果是不确定的。

在您的情况下，您正在调用 #'identity 并连接来自引用列表的破坏性值，即。字面数据。行为未定义。

使用新分配的列表

如果您调用 identity 而不是 copy-list，则每个中间结果都是一个新列表，并且结果已定义：

(equalp (apply #'nconc (maplist #'copy-list '(1 2 3)))
        (mapcon #'copy-list '(1 2 3)))
=> T

偶然循环列表

如果您使用像 (list 1 2 3) 这样的非文字数据，行为仍然是未定义的，但这更加微妙。例如，让我们打印 (maplist #'identity (list 1 2 3)) 的结果，同时注意循环：

(write (maplist #'identity (list 1 2 3)) :circle t)

这将打印以下内容，其中 #n= 是标签（读取器变量）和 #n# 向后引用与先前标记的相同列表：

((1 . #1=(2 . #2=(3))) #1# #2#)

换句话说，结果是三个列表 (L1 L2 L3) 的列表，其中 L2 是 L1 的其余部分，L3 是 L2 的其余部分.这意味着，如果您这样做：

(apply #'nconc (maplist #'identity (list 1 2 3)))

就好像你做到了：

(let* ((L1 (list 1 2 3))
       (L2 (rest L1))
       (L3 (rest L2)))
  (nconc L1 L2 L3))

给定上面的递归定义，它等价于：

(nconc (nconc L1 L2) L3)
^      ^
|      |
|      \-- inner nconc (N1)
|
\-- outer nconc (N0)

内项 N1 本身被评估为：

(progn (rplacd (last L1) L2) L1)

此处，L1 的结尾链接到 L2（L1 的其余部分），从而创建了一个循环。您可以直接尝试，您的环境应该打印它被省略；例如在 SBCL 中：

* (setf *print-length* 10)
10

* (let ((L1 (list 1 2 3)))
    (nconc L1 (rest L1)))
(1 2 3 2 3 2 3 2 3 2 ...)

您也可以通过将 *print-circle* 设置为 T 将其打印到 REPL。

这本身很好，但是这个无限列表用于上面名为 N0 的 nconc 外部调用。假设评估 N1 的中间结果是 R1：

(nconc R1 L3)

以上评价为：

(progn (rplacd (last R1) L3) R1)

这里程序卡住了，因为 last 永远不会终止。

至少，在大多数实现中都是这种情况，但请注意，LAST 仅在列表不是循环时才定义：

list---列表，可以是点列表，但不能是循环列表。

这就是为什么这里的行为实际上是未定义的。

刚刚偶然发现了一个解释：“如果 FN 结果是新鲜列表（非共享），结果与 (APPLY #'APPEND (MAPLIST ...)) 相同.” (Simplified Common Lisp reference)

(apply #'nconc (maplist #'copy-list '(1 2 3)))
(mapcon #'copy-list '(1 2 3))

有趣的是，Hyperspec 中并没有提到这一点。这能推导出来吗？