在 Prolog 中使用差异列表附加元素的问题

Question

我在this answer 中找到了这个 Prolog 代码，它使用差异列表实现了一个队列：

%% empty_queue(-Queue)
% make an empty queue
empty_queue(queue(0, Q, Q)).

%% queue_head(?Queue, ?Head, ?Queue0)
% Queue, with Head removed, is Queue0
queue_head(queue(s(X), [H|Q], Q0), H, queue(X, Q, Q0)).

%% queue_last(+Queue0, +Last, -Queue)
% Queue0, with Last at its back, is Queue
queue_last(queue(X, Q, [L|Q0]), L, queue(s(X), Q, Q0)).

这样做会按预期工作：

..., empty_queue(Q), queue_last(Q, 999, Q_), writeln(Q_), ....

我明白了

queue(s(0),[999|_3076],_3076)

如果我用这个 sn-p 观察 Q 的值，也很有趣：

empty_queue(Q), writeln(Q), queue_last(Q, 999, Q_), writeln(Q)

我明白了：

queue(0,_3750,_3750)
queue(0,[999|_3758],[999|_3758])

我想应该是这样的，因为差异导致空列表，所以它们有点等价。

问题是，在命令之后

queue_last(Q, 999, Q_)

我不能重用Q 来创建Q__，例如：

empty_queue(Q), queue_last(Q, 999, Q_), queue_last(Q, 888, Q__)

因为queue_last(queue(X, Q, [L|Q0]), L, queue(s(X), Q, Q0)).的绑定失败。

L = 888, L = 999 (tries to be both)

我该如何解决这个问题？有一些解决方法吗？ （总是使用差异列表）

Answer 1

我不能重用Q 来创建Q__

那是因为您必须使用您称之为Q_ 的“线程化”新结构。旧的Q 是燃烧器，必须丢弃。它不再正确描述“差异列表”。

?- empty_queue(Q1), 
   queue_last(Q1, 999, Q2), 
   queue_last(Q2, 888, Q3).

Q1 = queue(0,[999,888|_14714],[999,888|_14714]),   % Useless
Q2 = queue(s(0),[999,888|_14714],[888|_14714]),    % Burnt
Q3 = queue(s(s(0)),[999,888|_14714],_14714).       % Correct, valid

在empty_queue(Q1) 调用之后，这是Q1：

queue
├── arg 0: 0
├── arg 1: ----+---> <empty cell #1>
|              |
└── arg 2: ----+

在queue_last(Q1, 999, Q2) 调用之后，这是Q1 和Q2：

Q1（无效）

queue
├── arg 0: 0
├── arg 1: ----+---->[|]
|              |     / \
|              |  999  <empty cell #2>
|              |
└── arg 2: ----+

Q2（有效）

queue
├── arg 0: s(0)
├── arg 1: --------->[|]
|                    / \
|                 999  <empty cell #2>
|                          ^
|                          |
└── arg 2: ----------------+

在queue_last(Q2, 888, Q3) 调用之后，这是Q1、Q2 和Q3：

Q1（无效）

queue
├── arg 0: 0
├── arg 1: ----+---->[|]
|              |     / \
|              |  999   [|]
|              |       /   \
└── arg 2: ----+    888    <empty cell #3>

Q2（无效）

queue
├── arg 0: s(0)
├── arg 1: --------->[|]
|                    / \
|                 999  [|]<------------------+
|                      /  \                  |
|                   888   <empty cell #3>    |
|                                            |
└── arg 2: ----------------------------------+

Q3（有效）

queue
├── arg 0: s(s(0))
├── arg 1: --------->[|]
|                    / \
|                 999  [|]
|                      /  \              
|                   888   <empty cell #3>
|                                ^
|                                | 
└── arg 2: ----------------------+

Answer 2

不能重新分配 Prolog 变量。你不能重复使用它们。我不知道调用变量“烧毁”是否有很大帮助，它们没有被烧毁，它们绑定到一个具体的值。

不要使用“write”和朋友，除非你正在做一些复杂的打印式调试。在顶层尝试一下，无论如何您都会打印出所有内容。以下是使用此队列实现的方法。请注意，我使用的是Q0、Q1、Q2 等，因为一旦有多个下划线，我就无法计算下划线。

Enqueueinga，然后在队列末尾b：

?- empty_queue(Q0), queue_last(Q0, a, Q1), queue_last(Q1, b, Q2).
Q0 = queue(0, [a, b|_15096], [a, b|_15096]),
Q1 = queue(s(0), [a, b|_15096], [b|_15096]),
Q2 = queue(s(s(0)), [a, b|_15096], _15096).

排队 a，然后是 b，然后弹出您排队的第一个值（FIFO 顺序）：

?- empty_queue(Q0), queue_last(Q0, a, Q1), queue_last(Q1, b, Q2), 
    queue_head(Q2, Popped, Q3).
Q0 = queue(0, [a, b|_17772], [a, b|_17772]),
Q1 = queue(s(0), [a, b|_17772], [b|_17772]),
Q2 = queue(s(s(0)), [a, b|_17772], _17772),
Popped = a,
Q3 = queue(s(0), [b|_17772], _17772).

在前面推两次，然后弹出（LIFO order）：

?- empty_queue(Q0), queue_head(Q1, x, Q0), queue_head(Q2, y, Q1), 
    queue_head(Q2, Popped, Q3).
Q0 = queue(0, _21688, _21688),
Q1 = Q3, Q3 = queue(s(0), [x|_21688], _21688),
Q2 = queue(s(s(0)), [y, x|_21688], _21688),
Popped = y.

我在您的问题下方的评论中链接的答案（这里又是：https://stackoverflow.com/a/31925828/14411997）详细解释了它是如何工作的。它还具有其他相关 Q/A 等的链接。