"Out of stack" error on a simple Prolog predicate - list

Question

I've been practicing Prolog. The function I'm trying to write is compose(L1, L2, L3). It consists of the element of L1 and L2 interleaved in order until one of them becomes nil, and then appends that non-nil list at the end. The function works perfectly fine when it is given L1 and L2 as input(ie it prints out the correct L3) but I run into an "out of stack" error when I input L3 and try to get all the logically possible inputs L1 and L2. For example, for the following function code,
compose([],[],[]).
compose(L1,[],L3):-
append(L1,[],L3).
compose([],L2,L3):-
append([],L2,L3).
compose([H1|T1],[H2|T2],L3):-
compose(T1,T2,Tail),
append([H1],[H2],Head),
append(Head,Tail,L3).
?-compose(L1,L2,[a,b,c]).
will give me an out of stack error. How should I solve this issue?

Answer 1

How should I solve this issue?
First, try to understand why your query does not terminate. You can try to imagine how Prolog proceeds, but be warned, this can get pretty complex. After all, Prolog combines two control flows (AND- and OR-control) plus it has partially unknown data which do not exist in more traditional languages (OO and FP). For this reason, I prefer not to imitate Prolog, instead I let Prolog help me to localize the error. To this end, I add as many goals false as possible into your program such that the query still does not terminate. Here is the maximum, called a failure-slice:
compose([],[],[]) :- false.
compose(L1,[],L3):- false,
append(L1,[],L3).
compose([],L2,L3):- false,
append([],L2,L3).
compose([H1|T1],[H2|T2],L3):-
compose(T1,T2,Tail), false,
append([H1],[H2],Head),
append(Head,Tail,L3).
?- compose(L1, L2, [a,b,c]), false.
We can skip over your first clauses. Only the first goal of the last rule is of interest! So nothing more than:
compose([H1|T1],[H2|T2],L3):-
compose(T1,T2,Tail), false,
... .
?- compose(L1, L2, [a,b,c]), false.
In this tiny little program, the third argument of compose/3 is completely ignored. Nobody wants L3. And thus, L3 has no influence on termination. To make this terminate we need somehow constrain L3 prior to the goal. The other answer shows you how.
(This method works for any non-termination problem of a pure Prolog program, see failure-slice for more.)

Answer 2

First re-write it as a simpler yet fully equivalent
compose([],[],[]). % some redundancy here
compose(L1,[],L1).
compose([],L2,L2). /*
compose([H1|T1],[H2|T2],L3):- % whole solution
compose(T1,T2,Tail),
Head = [H1,H2],
L3 = [Head|Tail]. */
which now makes it clear the problem is with the recursion, first calculating the rest of the result (Tail), and only then completing it (as L3).
Instead, twist it,
compose([H1|T1],[H2|T2],[H1,H2|Tail]):- % single step
compose(T1,T2,Tail).
so that now we have co-recursion, and a productive one at that. It first creates the (assuredly finite) starting portion of the result, and fills the missing pieces later.
(In the above, "creates" can be interchanged with "consumes", as is the double-directional nature of Prolog. Being single-step, it doesn't care which arguments are consumed, and which are produced).

Answer 3

An "Out of global stack" error usually means that your recursion got stuck in an infinite loop, and thus keeps calling a predicate, until the stack is exhausted.
The reason this here gets in an infinte loop is because it will first emit results:
?- compose(L1,L2,[a,b,c]).
L1 = [a, b, c],
L2 = [] ;
L1 = [],
L2 = [a, b, c] ;
L1 = [a, c],
L2 = [b] ;
But then it will look for more solutions. It does that, based on your program, by each time unifing the first item with [H1|T1], and the second with [H2|T2]. You then immediately make a recursive call, so Prolog can not check if the H1 and the H2 are actually the first two elements in the third parameter.
We however do not need all these append/3 calls, etc. in the first place. We can perform simple unification on the parameters:
compose([],L2,L2).
compose(L1,[],L1).
compose([H1|T1],[H2|T2],[H1, H2|T3]) :-
compose(T1,T2,T3).
For the given query this will terminate after the proposed solution:
?- compose(L1,L2,[a,b,c]).
L1 = [],
L2 = [a, b, c] ;
L1 = [a, b, c],
L2 = [] ;
L1 = [a],
L2 = [b, c] ;
L1 = [a, c],
L2 = [b] ;
false.
Indeed, since due to the recursion, eventually the third parameter will be an empty list, and thus fail to unify with the [H1, H2|T3] list.