For length/2 how to add human readable variable names

Question

How can human readable variable names be displayed for system generated variable names?

As a simple example:

?- length(Ls,N).
Ls = [],
N = 0 ;
Ls = [_5112],
N = 1 ;
Ls = [_5112, _5118],
N = 2 ;
Ls = [_5112, _5118, _5124],
N = 3

would be nicer as

?- length(Ls,N).
Ls = [],
N = 0 ;
Ls = [a],
N = 1 ;
Ls = [a, b],
N = 2 ;
Ls = [a, b, c],
N = 3

mapping

_5112 = a
_5118 = b
_5124 = c

Details

The closest solution I found uses read_term/2 as demonstrated in this answer with the variable_names(Vars) option, however my problem does not use read_term to get the term from the console.

If this is a duplicate let me know; I could not find one.

The real problem is based on generating test case data:

?- length(Ls,N),list_partitionedNU(Ls,Ps).
Ls = Ps, Ps = [],
N = 0 ;
Ls = [_5242],
N = 1,
Ps = [[_5242]] ;
Ls = [_5242, _5248],
N = 2,
Ps = [[_5242], [_5248]] ;
Ls = [_5242, _5248],
N = 2,
Ps = [[_5242, _5248]] ;
Ls = [_5242, _5248, _5254],
...

See this and this for list_partitionedNU/2.

Follow up after answers.

Based on answer by William

partitions(Ps) :-
  length(Ls,N),
  assign(Ls),
  list_partitionedNU(Ls,Ps).

?- partitions(Ps).
Ps = [] ;
Ps = [[a]] ;
Ps = [[a], [b]] ;
Ps = [[a, b]] ;
Ps = [[a], [b], [c]] ;
Ps = [[a], [b, c]] ;
Ps = [[a, b], [c]] ;
Ps = [[a, c], [b]] ;
Ps = [[a, b, c]] ;
Ps = [[a], [b], [c], [d]] ;
Ps = [[a], [b], [c, d]] ;
Ps = [[a], [b, c], [d]] ;
Ps = [[a], [b, d], [c]] ;
Ps = [[a], [b, c, d]] ;
Ps = [[a, b], [c], [d]] ;
Ps = [[a, c], [b], [d]] ;
Ps = [[a, d], [b], [c]] ;
Ps = [[a, b], [c, d]] ;
Ps = [[a, c], [b, d]] ;
Ps = [[a, d], [b, c]] ;
Ps = [[a, b, c], [d]] ;
Ps = [[a, b, d], [c]] ;
Ps = [[a, c, d], [b]] ;
Ps = [[a, b, c, d]] ;
...

Based on answer by CapelliC

partitions(Ps) :-
    length(Ls,N),
    numbervars(Ls,0,N),
    list_partitionedNU(Ls,Ps).

?- partitions(Ps).
Ps = [] ;
Ps = [[A]] ;
Ps = [[A], [B]] ;
Ps = [[A, B]] ;
Ps = [[A], [B], [C]] ;
Ps = [[A], [B, C]] ;
Ps = [[A, B], [C]] ;
Ps = [[A, C], [B]] ;
Ps = [[A, B, C]] ;
Ps = [[A], [B], [C], [D]] ;
Ps = [[A], [B], [C, D]] ;
Ps = [[A], [B, C], [D]] ;
Ps = [[A], [B, D], [C]] ;
Ps = [[A], [B, C, D]] ;
Ps = [[A, B], [C], [D]] ;
Ps = [[A, C], [B], [D]] ;
Ps = [[A, D], [B], [C]] ;
Ps = [[A, B], [C, D]] ;
Ps = [[A, C], [B, D]] ;
Ps = [[A, D], [B, C]] ;
Ps = [[A, B, C], [D]] ;
Ps = [[A, B, D], [C]] ;
Ps = [[A, C, D], [B]] ;
Ps = [[A, B, C, D]] ;
...

You could "walk" through the functor, and each time assign variables you obtain the next "name" you store in an accumulator. — Willem Van Onsem, Jan 30 '19 at 21:02
Beware constraints! You are unifying actual variables that might be connected to constraints. For your example, consider `length(Xs, 5),clpfd:all_different(Xs)` — false, Jan 31 '19 at 00:03

score 4 · Answer 1 · answered Jan 30 '19 at 23:34

4

Let's not forget the obvious option: a different Prolog processor.

Using SICStus Prolog 4.5.0 (try full-featured SICStus Prolog 30 days for free):

| ?- Xs = [_C,f(_E)|_], length(Xs,N).
N = 2, Xs = [_C,f(_E)] ? ;
N = 3, Xs = [_C,f(_E),_A] ? ;
N = 4, Xs = [_C,f(_E),_A,_B] ? ;
N = 5, Xs = [_C,f(_E),_A,_B,_D] ? ;
N = 6, Xs = [_C,f(_E),_A,_B,_D,_F] ? ;
N = 7, Xs = [_C,f(_E),_A,_B,_D,_F,_G] ? ...

answered Jan 30 '19 at 23:34

repeat

18,496
4
54
166

1

Remarkable how SICStus avoids already used variable names `_C` and `_E` – false Jan 31 '19 at 10:29
1

@false. Smart indeed. Why is there no portable "best" toplevel? – repeat Jan 31 '19 at 12:35
1

That needs to be written – false Jan 31 '19 at 13:32

score 2 · Answer 2 · edited Jan 30 '19 at 22:35

2

The oldie but goldie numbervars/3 has been revisited:

?- length(L,5),numbervars(L,0,N).
L = [A, B, C, D, E],
N = 5.

not sure it's really useful, but it is nice to explore...

?- length(L,5),numbervars(L,0'a,N).
L = [T3, U3, V3, W3, X3],
N = 102.

edited Jan 30 '19 at 22:35

Guy Coder

24,501
8
71
136

answered Jan 30 '19 at 21:55

CapelliC

59,646
5
47
90

We can use that in combination with [`term_variables/2`](http://www.swi-prolog.org/pldoc/doc_for?object=term_variables/2) to let it work on arbitrary terms. – Willem Van Onsem Jan 30 '19 at 21:57
1

What exactly has been revisited in `numbervars/3`? – false Jan 31 '19 at 10:28
1

@false: IRC was once more a pattern like '$VAR'(N). But I'm not so sure, let me know... anyway, I left implicit that even if we get such pattern, a maplist could be applied to make sense of the data. – CapelliC Jan 31 '19 at 10:50
(What do you mean by IRC ...??) `numbervars/3` is defined as ever with `'$VAR'/1` terms – false Jan 31 '19 at 19:52
@false: sorry, was IIRC ... a mistake in mistake :) – CapelliC Jan 31 '19 at 20:26
1

@CapelliC in SWI, try `length(L,5),numbervars(L,0,N) ; true.`. when presented with `;`, press "w". :) (to undo, repeat, and press "p".) – Will Ness Feb 01 '19 at 20:03
(of course `write_canonical` does the same, but "w" is less keys to type :) ). – Will Ness Feb 02 '19 at 08:31

Willem Van Onsem · Accepted Answer · 2019-01-30T21:26:21.553

We can construct a predicate that "assigns" values to the variables in a functor in a recursive fasion, with an accumulator that keeps track of the latest "name" assigned.

For example:

assign(Term) :-
    assign(Term, 97, _).

assign(X, N, N1) :-
    var(X),
    !,
    char_code(X, N),
    N1 is N+1.
assign(F, N, N1) :-
    F =.. [_|A],
    assign_list(A, N, N1).

assign_list([], N, N).
assign_list([H|T], N, NT) :-
    assign(H, N, N1),
    assign_list(T, N1, NT).

For example:

?- length(L, _), assign(L).
L = [] ;
L = [a] ;
L = [a, b] ;
L = [a, b, c] ;
L = [a, b, c, d] ;
L = [a, b, c, d, e] ;
L = [a, b, c, d, e, f] .
?- Q = [L, [_, _]], length(L, _), assign(Q).
Q = [[], [a, b]],
L = [] ;
Q = [[a], [b, c]],
L = [a] ;
Q = [[a, b], [c, d]],
L = [a, b] ;
Q = [[a, b, c], [d, e]],
L = [a, b, c] .

We thus "walk" through the tree and assign values to the variables. With the above implementation we do not take into account existing constants. So we might assign values that already exist to the variables. Furthermore we just keep incrementing the character code, so eventually we will reach symbols, control characters, and characters.

The above shortcomings can however be "solved" by first inspecting the functor and obtaining a list of constants to skip. Furthermore the generator of terms can of course be improved, for example by yielding aa after z.

@DanielLyons pointed to the term_variables/2 predicate, which can ease the assign/1 predicate a lot, like:

assign(Term) :-
    term_variables(Term, Vars),
    assign_list(Vars, 97).

assign_list([], _).
assign_list([H|T], N) :-
    char_code(H, N),
    N1 is N+1,
    assign_list(T, N1).

This of course still does not solves the above stated shortcomings, although, as said, we can solve these by using something else than char_code to obtain a constant name, and by first making a wak to look for constants in use.

For length/2 how to add human readable variable names

3 Answers3