我只与Prolog合作了几天。我理解一些事情，但这真让我感到困惑。
我想要编写一个带有列表并将其展平的函数。
?- flatten([a,[b,c],[[d],[],[e]]],Xs).
Xs = [a,b,c,d,e]. % expected result
该函数取出列表的内部结构。
这是我到目前为止：
flatten2([],[]).
flatten2([Atom|ListTail],[Atom|RetList]) :-
atom(Atom), flatten2(ListTail,RetList).
flatten2([List|ListTail],RetList) :-
flatten2(List,RetList).
现在，这在我打电话时起作用：
?- flatten2([a,[b,c],[[d],[],[e]]], R).
R = [a,b,c,d,e]. % works as expected!
但是当我打电话来查看我输入的列表是否已被展平时，返回false而不是true：
?- flatten2([a,[b,c],[[d],[],[e]]], [a,b,c,d,e]).
false. % BAD result!
为什么一方面工作，另一方面又不工作？我觉得我错过了很简单的事情。
你给出的flatten2/2的定义被破坏了;它实际上表现得像这样：
?- flatten2([a, [b,c], [[d],[],[e]]], R).
R = [a, b, c] ;
false.
所以，鉴于你已经将R绑定到[a,b,c,d,e]的情况，失败并不令人惊讶。
你的定义是抛弃第3个子句中的列表尾部（ListTail） - 这需要整理并连接回列表以通过RetList返回。这是一个建议：
flatten2([], []) :- !.
flatten2([L|Ls], FlatL) :-
!,
flatten2(L, NewL),
flatten2(Ls, NewLs),
append(NewL, NewLs, FlatL).
flatten2(L, [L]).
这个递归地将所有列表列表减少到单个项目列表[x]，或者将它丢弃的空列表[]。然后，它累积并将它们全部附加到输出中的一个列表中。
请注意，在大多数Prolog实现中，空列表[]是一个原子和一个列表，因此对atom([])和is_list([])的调用都评估为true;这不会帮助你抛弃空列表而不是字符原子。
您可以使用指向其开头的指针和结尾处的“结束孔/自由指针”（即logvar）来保持列表的开放性，然后您可以在到达结束时实例化它：
flatten2( [], Z, Z):- !. % ---> X
flatten2( [Atom|ListTail], [Atom|X], Z) :- % .
\+is_list(Atom), !, % .
flatten2( ListTail, X, Z). % Y
flatten2( [List|ListTail], X, Z) :- % .
flatten2( List, X, Y), % from X to Y, and then % .
flatten2( ListTail, Y, Z). % from Y to Z % Z --->
然后你把它称为
flatten2( A, B):- flatten2( A, B, []).
这样就没有必要在任何地方使用reverse。这种技术被称为“差异列表”，但将其视为“开放式列表”则更容易。
更新：使用dcg语法更容易编码。由于它是单向的（第一个参数必须完全接地），为什么不使用切割：
flattn([]) --> [], !.
flattn([A|T]) --> {\+is_list(A)}, [A], !, flattn(T).
flattn([A|T]) --> flattn(A), flattn(T).
测试：
16 ?- phrase(flattn([a,[b,c],[[d],[],[e]]]), [a, b, c, d, e]).
true.
17 ?- phrase(flattn([a,[b,c],[[d],[],[e]]]), R).
R = [a, b, c, d, e].
18 ?- phrase(flattn([a,[b,X],[[d],[],[e]]]), [a, b, c, d, e]).
X = c.
如果定义完全是声明性的，那么最后一个也应该用X=[c] ; X=[[],c] ; ... ; X=[[c]] ; ...成功;唉，事实并非如此。
（编辑2：简化了两个版本，感谢@ mat的评论！）
Prolog的列表符号是非常简单的prolog术语之上的语法糖。 Prolog列表如下表示：
[]表示。为什么？因为这看起来像空列表的数学符号。他们可以使用像nil这样的原子来表示空列表，但他们没有。.\2表示，其中第一个（最左边）参数是列表的头部，第二个（最右边）参数是列表的尾部，递归地，它本身是一个列表。一些例子：
[]表示为原子：
[]
[a]在内部存储为
.(a,[])
[a,b]这两个元素的列表在内部存储为
.(a,.(b,[]))
[a,b,c]是三个元素的列表，内部存储为
.(a,.(b,.(c,[])))
检查列表的头部也是同样的符号的语法糖：
[X|Xs]与.(X,Xs)相同[A,B|Xs]与.(A,.(B,Xs))相同[A,B]（见上文）与.(A,.(B,[]))相同我自己，我会像这样写flatten/2：
%------------------------
% public : flatten a list
%------------------------
flatten( X , R ) :-
flatten( X , [] , T ) ,
reverse( T , R )
.
%--------------------------------------------
% private : flatten a list into reverse order
%--------------------------------------------
flatten( [] , R , R ) . % the empty list signals the end of recursion
flatten( [X|Xs] , T , R ) :- % anything else is flattened by
flatten_head( X , T , T1 ) , % - flattening the head, and
flatten( Xs , T1 , R ) % - flattening the tail
. %
%-------------------------------------
% private : flatten the head of a list
%-------------------------------------
flatten_head( X , T , [X|T] ) :- % if the head is a not a list
\+ list(X) , % - simply prepend it to the accumulator.
! . %
flatten_head( X , T , R ) :- % if the head is a list
flatten( X , T , R ) % - recurse down and flatten it.
.
%-----------------------
% what's a list, anyway?
%-----------------------
list( X ) :- var(X) , ! , fail .
list( [] ) .
list( [_|_] ) .
在if_//3和list_truth/2的基础上，我们可以实现myflatten/2如下：
myflatten(Xs,Ys) :-
phrase(myflatten_aux(Xs),Ys).
myflatten_aux([]) --> [].
myflatten_aux([T|Ts]) -->
if_(neither_nil_nor_cons_t(T), [T], myflatten_aux(T)),
myflatten_aux(Ts).
:- use_module(library(dialect/sicstus/block)).
:- block neither_nil_nor_cons(-).
neither_nil_nor_cons(X) :-
\+nil_or_cons(X).
nil_or_cons([]).
nil_or_cons([_|_]).
neither_nil_nor_cons_t(X,Truth) :-
( nonvar(X)
-> ( neither_nil_nor_cons(X) -> Truth = true
; Truth = false
)
; nonvar(Truth)
-> ( Truth == true -> neither_nil_nor_cons(X)
; Truth == false, nil_or_cons(X)
)
; Truth = true, neither_nil_nor_cons(X)
; Truth = false, nil_or_cons(X)
).
示例查询（取自其他答案，以及对答案的评论）：
?- myflatten([[4],[[5,6],[7,[8],[9,[10,11]]]]], Xs).
Xs = [4, 5, 6, 7, 8, 9, 10, 11].
?- myflatten([1,[8,3],[3,[5,6],2],8], Xs).
Xs = [1, 8, 3, 3, 5, 6, 2, 8].
?- myflatten([a,[b,c],[],[[[d]]]], Xs).
Xs = [a, b, c, d].
?- myflatten([a,[b,c],[[d],[],[e]]], Xs).
Xs = [a, b, c, d, e].
neither_nil_nor_cons_t和not(nil_or_cons_t)描述有相同的解决方案，但解决方案顺序不同。考虑：
?- myflatten([A,B,C],Xs), A=a,B=b,C=c.
A = a,
B = b,
C = c,
Xs = [a, b, c] ; % does not terminate universally
这是一个基于累加器的完整性版本：
% flatten/2
flatten(List, Result) :- flatten(List, [], Result).
% auxiliary predicate flatten/3
flatten([], Result, Result).
flatten([Head| Tail], Part, Result) :-
is_list(Head),
!,
flatten(Head, HR),
append(Part, HR, PR),
flatten(Tail, PR, Result).
flatten([Head| Tail], Part, Result) :-
append(Part, [Head], PR),
flatten(Tail, PR, Result).
flatten(X, Part, Result) :-
fail.
我没有找到使用findall的解决方案，所以我将添加它。 （如果列表是地面，它将起作用）
首先，我们定义如何测试列表：
list(X) :- var(X), !, fail.
list([]).
list([_|_]).
和transitive closure的member，我们称之为member*：
'member*'(X, Y) :- member(X, Y).
'member*'(X, Y) :- member(Z, Y), 'member*'(X, Z).
扁平列表是member*的所有解决方案，它们不是列表：
flatten(X, Y) :- findall(Z, ('member*'(Z, X), \+ list(Z)), Y).
例：
?- flatten([[4],[[5,6],[7,[8],[9,[10,11]]]]],Y).
Y = [4, 5, 6, 7, 8, 9, 10, 11].
没有任何其他谓词，只有尾递归。
flatten([[X|S]|T], F) :- flatten([X|[S|T]], F).
flatten([[]|S], F) :- flatten(S, F).
flatten([X|S], [X|T]) :- \+(X = []), \+(X = [_|_]), flatten(S, T).
flatten([], []).