Learn Prolog Now 翻译 - 第六章 - 列表补遗 - 第一节，列表合并

内容提要：

 列表合并的定义

 列表合并的使用

 

列表合并的定义

 我们将会定义一个很重要的谓词：append/3，其中所有的参数都是列表。从声明性角度去看，append(L1, L2, L3)的含义是列表L3是列表L1和列表L2的合并结果（合并意味着连接）。比如，

如果我们查询：

   ?- append([a, b, c], [1, 2, 3], [a, b, c, 1, 2, 3]).

 或者查询：

   ?- append([a, [foo, gibble], c], [1, 2, [[], b]], [a, [foo, gibble], c, 1, 2, [[], b]]).

 Prolog会回答true。

 但是，如果我们查询：

   ?- append([a, b, c], [1, 2, 3], [a, b, c, 1, 2]).

 或者查询：

   ?- append([a, b, c], [1, 2, 3], [1, 2, 3, a, b, c]).

 Prolog会回答false。

 从程序性的角度来说，append/3最为有用的作用是连接两个列表。我们可以在第三个参数中使用变量，轻松地达到目的：

   ?- append([a, b, c], [1, 2, 3], L3).

   L3 = [a, b, c, 1, 2, 3].

 但是（我们将会看到）我们也可以使用append/3分割列表。事实上，append/3是一个真正多用途的谓词，我们可以通过它做很多事情，并且通过学习这个谓词，我们可以更好地理解在

Prolog中如何操作列表。

 

 如下是append/3的定义：

   append([], L, L).

   append([H|T1], L2, [H|T3]) :- append(T1, L2, T3).

 这是一个递归形式的定义。基础子句很简单：将一个空列表和任意列表进行合并，那么结果是和任何列表相同的列表，这显然是正确的。

 那么递归的部分呢？含义是：如果我们将一个非空列表，[H|T]和另外一个列表L2进行合并，那么得到的列表是头部为H，并且尾部是T和L2合并的结果。图示可能会更清楚：

   Input: [H | T ] + L2

   Result: [ H |  T + L2]

 

 但是这个定义的程序性含义是什么？当两个列表发生合并时实际会如何操作？让我们根据细节的分解来进一步学习，例子还是查询：

   ?- append([a, b, c], [1, 2, 3], X).

 当我们进行这个查询时，Prolog将会使用递归子句去进行匹配，并且生成一个新的中间变量（比如称为_G518），如果我们跟踪接下来的步骤，可能如下：

   append([a, b, c], [1, 2, 3], _G518).

   append([b, c], [1, 2, 3], _G587).

   append([c], [1, 2, 3], _G590).

   append([], [1, 2, 3], _G593).

   append([], [1, 2, 3], [1, 2, 3]).

   append([c], [1, 2, 3], [c, 1, 2 ,3]).

   append([b, c], [1, 2, 3], [b, c, 1, 2, 3]).

   append([a, ,b, c], [1, 2, 3], [a, b, ,c, 1, 2, 3]).

   X = [a, b, c, 1, 2, 3].

   true

 

 这种求解的模式很清晰：前四行可以看见Prolog通过递归定义的方法遍历完第一个列表；然后，接下来的四行显示，Prolog接下来回填每个中间结果，如何执行的呢？通过依次初始化变量：

_G593，_G590，_G587和_G518。但是这里学习的关键是把握这种基础模式，而不仅仅局限于append/3的实现。所以，我们可以更深入地研究，如下是查询，append([a, b, c], [1, 2, 3], X)

的搜索树，我们将会仔细标记每一个步骤，每一个中间目标，及其每一个变量的初始化值：

 

 1. Goal 1：append([a, b, c], [1, 2, 3], _G518)。Prolog将其和递归规则的头部合一。所以_G518和[a | T3]合一，同时Prolog有了新的目标，append([b, c], [1, 2, 3], T3)，这会为T3生成

一个新的变量，_G587，所以我们可以知道：_G518 = [a | _G587]。

 2. Goal 2：append([b, c], [1, 2, 3], _G587)。Prolog将其和递归规则的头部合一，所以_G587和[b | T3]合一，Prolog有了新的目标，append([c], [1,2 ,3], T3)，这会为T3生成一个新的变量，

_G590，所以我们可以知道：_G587 = [b | _G590]。

 3. Goal 3：append([c], [1, 2, 3], _G590)。Prolog将其和递归规则的头部合一，所以_G590和[c | T3]合一，Prolog有了新的目标，append([], [1, 2, 3], T3)，这会为T3生成一个新的变量，

_G593，所以我们可以知道：_G590 = [c | _G593]。

 4. Goal 4：append([], [1, 2, 3], _G593)。最终，Prolog可以使用基础子句（即，append([], L, L)）了，所以在接下来的连续4个步骤，Prolog会获取Goal 4, Goal 3, Goal 2, Goal 1的答案：

 5. Goal 4 的答案： append([], [1, 2, 3], [1, 2, 3])，这是因为当我们使用基础子句匹配Goal 4时，_G593将和[1, 2, 3]合一。

 6. Goal 3 的答案： append([c], [1, 2, 3], [c, 1, 2, 3])，为什么？因为 Goal 3是，append([c], [1, 2, 3], _G590)，同时_G590是列表[c | _G593]，我们已经将_G593和[1, 2, 3]合一，所以

_G590将和[c, 1, 2, 3]合一。

 7. Goal 2 的答案：append([b, c], [1, 2, 3], [b, c, 1, 2, 3])。为什么？因为Goal 2是，append([b, c], [1, 2, 3], _G587)，同时_G587是列表[b | _G590]，我们已经将_G590和[c, 1, 2, 3]合一，

所以_G587将和[b, c, 1, 2, 3]合一。

 8. Goal 1 的答案：append([a, b, c], [1, 2, 3], [a, b, c, 1, 2, 3])，为什么？因为Goal 1是，append([a, b, c], [1, 2, 3], _G518)，同时_G518是列表[a | _G587]，我们已经将_G587和

[b, c, 1, ,2 ,3]合一，所以_G518将和[a, b, c, 1, 2, 3]合一。

 9. 所以Prolog现在已经知道如何初始化X，这个原始的查询变量，它会告诉结果，X = [a, b, c, 1, 2, 3]，正如我们期望的一样。

 

 请仔细思考上面的例子，并且确保完全理解变量初始化的模式，即：

   _G518 = [a | _G587]

   　　　 = [a | [b | _G590]]

  　　　  = [a | [b | [c | _G593]]]

 这种类型的模式就是append/3能够起作用的核心。而且，它展示出更为普通的主题：使用合一去构建结构。在核心层，append/3的递归调用会构建出嵌套模式的变量。当Prolog最终将

最里层的变量_G593和[1,2 ,3]合一，答案就会循环得出，就像是滚雪球一般。但是这仅仅是合一，不是其他什么魔法，就得出了结果。　

 

合并列表的使用

 现在我们已经了解了append/3的工作机制，来看看如何实际运用它。

 append/3的一个重要应用就是分割一个列表为两个连续的列表，比如：

   ?- append(X, Y, [a, b, c, d]).

   X = []

   Y = [a, b, c, d];

   X = [a]

   Y = [b, c, d];

   X = [a, b]

   Y = [c, d];

   X = [a, b, c]

   Y = [d];

   X = [a, b, c ,d]

   Y = [];

   false

 

 即，我们给出想要分割的列表（这里就是，[a, b, c, d]）作为append/3的第三个参数，同时我们使用变量代表前两个参数。Prolog就会进行搜索，将两个变量初始化，并且合并后的值就是

第三个参数的列表，即分割列表为两个。而且，正如例子的结果显示，通过回溯，Prolog能够找到所有可能的组合值。

 

 可以使用append/3定义许多其他有用的谓词。让我们思考一些例子。首先，我们可以定义一个谓词，找到列表的前缀，比如[a, b, c, d]的前缀是，[], [a], [a, b], [a, b, c]和[a, b, c, d]，在

append/3的协助下，定义prefix/2很容易，其中两个参数都是列表，比如prefix(P, L)将会得出P是L的前缀，如下：

   prefix(P, L) :- append(P, _, L).

 这个定义就是说，列表P是列表L的前缀，如果列表L是由列表P和其他列表合并而成的（使用匿名变量代表我们不在乎其他列表具体是什么，我们只是知道这里有其他列表存在）。这个谓词可以

成功找出列表的前缀，并且通过回溯，可以找出所有的可能值：

   ?- prefix(X, [a, b, c, d]).

   X = [];

   X = [a];

   X = [a, b];

   X = [a, b, c];

   X = [a, b, c, d];

   false

 

 类似地，我们可以定义一个谓词找出一个列表的后缀。比如，[a, b, c, d]的后缀是[], [d], [c, d], [b, c, d]和[a, b, c, d]。同样地，使用append/3可以方便地定义suffix/2，其中两个参数都是列表，

比如suffix(S, L)将会得出S是L的后缀，如下：

   suffix(S, L) :- append(_, S, L).

 这个定义就是说，列表S是列表L的后缀，如果列表L是由其他列表和列表S合并而成的，这个谓词可以成功找出列表的后缀，并且通过回溯，可以找出所有的可能值：

   ?- suffix(X, [a, b, c, d]).

   X = [a, b, c, d];

   X = [b, c, d];

   X = [c, d];

   X = [d];

   X = [];

   false

 请确认你能够理解为什么答案是这样的顺序。

 

 现在，可以十分轻松地定义一个谓词找出列表的子列表。[a, b, c, d]的子列表是，[], [a], [b], [c], [d], [a, b], [b, c], [c, d], [a, b, c], [b, c, d]和[a, b, c, d]。稍微想一下就能够知道一个列表的子

列表是这个列表的后缀的前缀，如图：

   获取后缀： a, b, c, d, e, f, g, 

   获取后缀：，m, n, o, p

   结果：h, i, j, k, l

 由于我们已经定义了列表前缀和后缀的谓词，所以子列表的谓词定义如下：

   sublist(SubL, L) :- suffix(S, L), prefix(SubL, S).

 即，SubL是L的子列表，如果存在列表S：S是L的后缀，并且SubL是S的前缀。这个谓词没有直接使用append/3，但是由于prefix/2和sufiix/2都使用了append/3，所以内部其作用的还是append/3。