Turn a tuple into a list - list

Question

I've searched and strangely didn't find much on this . How can I turn a tuple of unknown length into a list in prolog?
For example:
List=[1,2,3,4], Tuple=(1,2,3,4).

Answer 1

When you are stuck with term conversion, it is often a good idea to get an understanding of what a term actually denotes.
You can use write_canonical/1 to get the canonical form of a term.
In your case:
?- Tuple = (1,2,3,4), write_canonical(Tuple).
','(1,','(2,','(3,4)))
Tuple = (1, 2, 3, 4).
This makes it clear that we are actually talking about compound terms of the form (A,B)—written in prefix notation as ','(A,B)—whose arguments are either integers or again such compound terms. Such terms are also called "and lists" in Prolog, and Prolog goals also have such a shape. Note in particular that these are not really "tuples", certainly not in a "first class citizen" sense, only compound terms much like any other compound terms.
Thus, we only need to reason about these 2 possible cases:
integer
term of the form (A,B).
Further, when describing lists, always consider using dcg notation for convenience.
For example:
tuple_list(I) --> { integer(I) }, [I].
tuple_list((A,B)) --> tuple_list(A), tuple_list(B).
Now we have:
?- Tuple = (1,2,3,4), phrase(tuple_list(Tuple), Ls).
Tuple = (1, 2, 3, 4),
Ls = [1, 2, 3, 4].
This solves your task of converting from such terms to lists.
However, the most general query yields no answers:
?- phrase(tuple_list(Tuple), Ls).
ERROR: Out of local stack
I leave generalizing tuples_list//1 so that it works in all directions as an exercise.

Answer 2

You have got two useful answers already. As mentioned, you generally don't use a "tuple" in the notation (1, 2, 3, 4): this is not a flat data structure as in say Haskell, it is a nested data structure. The Prolog way would be to use a term with arity 4, for example, quadruple(1, 2, 3, 4). The name of course doesn't matter, but usually, you use a descriptive name of some sort.
Then, to convert the arguments of a term to a list, you use the "univ" operator =.. like this:
Term =.. [Name|Arguments]
so:
?- foo(1, 2, 3, 4) =.. [foo|Args].
Args = [1, 2, 3, 4].
In the special case of tuples with two elements (pairs), the functor -/2 is commonly used. The dash is also an infix operator, so you can write 1-a instead of -(1, a). Quite a few library predicates that work on pairs expect them as -/2, for example:
?- keysort([1-c, 2-a, -(0, b), 1-a], S).
S = [0-b, 1-c, 1-a, 2-a].

Answer 3

tuples in Prolog are rarely used, but a quick conversion could be
list_tuple([A,B|L], (A,R)) :- list_tuple([B|L], R).
list_tuple([A,B], (A,B)). % I don't think unary tuples make sense...
?- list_tuple([1,2,3,4],T).
T = (1, 2, 3, 4) ;
false.
this doesn't work very well on 'backward mode'
?- list_tuple(L,(1,2,3,4)).
L = [1, 2, 3, 4] ;
L = [1, 2, (3, 4)] ....
you can try to place a cut to get it deterministic, I've provided clauses in order as required...

Answer 4

Using SWI-Prolog, "tuples" and lists can be converted using the built-in library predicate comma_list/2.
comma_list(C, [1, 2, 3]).
% C = (1, 2, 3).
comma_list((1, 2, 3), L).
% L = [1, 2, 3].
comma_list((a, foo(bar), C), [a, B, c]).
% C = c,
% B = foo(bar).
See the documentation for more usage examples.
It can be a bit tricky to search for because the documentation doesn't necessarily refer to terms like (1, 2, 3) as a "tuple", but it describes them as a "nested term over the ,/2 functor". Also provided is semicolon_list/2 which will perform the same operations with the ;/2 functor instead.