Why in SWI Prolog, I get the result with `|` sign? - list

Question

I have the following code to group sequences of equivalent objects together:
pack([], []).
pack([X], [X]).
pack([H, T|TS], [H|TR]):-
H \= T,
pack([T|TS], TR).
pack([H, H|HS], [[H|TFR]|TR]):-
pack([H|HS], [TFR|TR]).
My input is:
pack([1,1,1,1,2,3,3,1,1,4,5,5,5,5], X).
And as a result I get:
[[1,1,1|1],2,[3|3],[1|1],4,[5,5,5|5]]
Have you noticed | sign before the last element in each list? I do not know why it appears and how to fix it. Any ideas?

Answer 1

A list is a data type that has two type of functors/constants:
the empty list [] which has no arguments; and
the "cons" [element|list].
As is denoted in the second option, the second parameter of a cons should be a list. This can be another cons (and thus recursively further), or an empty list. Nevertheless, Prolog is not really typed, so you can use an integer, character,... as second item, but then it is not a list.
So now the question is, "how do we construct such weird list". In this answer, I used a smaller example to reproduce the error, because it makes things easier:
?- trace.
true.
[trace] ?- pack([1,1], X).
Call: (7) pack([1, 1], _G1066) ? creep
Call: (8) 1\=1 ? creep
Fail: (8) 1\=1 ? creep
Redo: (7) pack([1, 1], _G1066) ? creep
Call: (8) pack([1], [_G1144|_G1141]) ? creep
Exit: (8) pack([1], [1]) ? creep
Exit: (7) pack([1, 1], [[1|1]]) ? creep
X = [[1|1]] .
If we thus pack two elements, something goes wrong. First we call pack([1,1],X).
First the third clause fires, but the H \= T item fails. So as a result Prolog redoes the call, but now with the last clause. In the last clause, we see something weird:
pack([H, H|HS], [[H|TFR]|TR]):-
pack([H|HS], [TFR|TR]).
What we see is that we perform a recursive call on pack/2 with [TFR|TR]. So that means [TFR|TR] should be a list of lists. But the second clause does not generate a list of lists, but only a list of items. So the error is in:
pack([X], [X]).
%% ^ list of items??
So what we need to do to resolve the error, is rewrite the second clause to:
pack([X], [[X]]).
%% ^ list of list
Now we have solved that problem, but we are still not there yet: there is also an type error in the third clause:
pack([H, T|TS], [H|TR]):-
%% ^ item instead of a list?
H \= T,
pack([T|TS], TR).
Again we can simply make it a list of items:
pack([H, T|TS], [[H]|TR]):-
%% ^ list
H \= T,
pack([T|TS], TR).
And now we obtain the following code:
pack([], []).
pack([X], [[X]]).
pack([H, T|TS], [[H]|TR]):-
H \= T,
pack([T|TS], TR).
pack([H, H|HS], [[H|TFR]|TR]):-
pack([H|HS], [TFR|TR]).
We then obtain:
?- pack([1,1,1,1,2,3,3,1,1,4,5,5,5,5], X).
X = [[1, 1, 1, 1], [2], [3, 3], [1, 1], [4], [5, 5, 5|...]] [write]
X = [[1, 1, 1, 1], [2], [3, 3], [1, 1], [4], [5, 5, 5, 5]] .
EDIT:
In case there is only one element, you apparently do not want to construct a list. That makes the problem a bit harder. There are two options:
we adapt the code such that if such element occurs, we do not add it to a list; or
we perform some post processing, where we "unlist" lists with one element.
The last one is quite trivial, so lets do the first one. In that case, the second clause should indeed read:
pack([X],[X]).
Now the second clause should read:
pack([H, T|TS], [H|TR]):-
H \= T,
pack([T|TS], TR).
as well. But the last clause, is harder:
pack([H, H|HS], [[H|TFR]|TR]):-
pack([H|HS], [TFR|TR]).
There are two possibilities here:
TFR is a list of items, in that case we simply prepend to the list; or
TFR is not a list, in which case we construct a list.
In order to solve this problem, we can define a predicate:
prepend_list(H,[HH|T],[H,HH|T]).
prepend_list(H,X,[H,X]) :-
X \= [_|_].
and then use:
pack([H, H|HS], [HTFR|TR]):-
pack([H|HS], [TFR|TR]),
prepend_list(H,TFR,HTFR).
So now we obtain:
pack([], []).
pack([X], [X]).
pack([H, T|TS], [H|TR]):-
H \= T,
pack([T|TS], TR).
pack([H, H|HS], [HTFR|TR]):-
pack([H|HS], [TFR|TR]),
prepend_list(H,TFR,HTFR).
prepend_list(H,[HH|T],[H,HH|T]).
prepend_list(H,X,[H,X]) :-
X \= [_|_].
Note however that this program will fail if you want to pack/2 lists itself. In that case you better use a post processing step anyway.
Now it constructs:
?- pack([1,1,1,1,2,3,3,1,1,4,5,5,5,5], X).
X = [[1, 1, 1, 1], 2, [3, 3], [1, 1], 4, [5, 5, 5|...]] [write]
X = [[1, 1, 1, 1], 2, [3, 3], [1, 1], 4, [5, 5, 5, 5]] .