singleton variables in prolog

Question

I was testing my new version of SWI prolog and keep coming across the error :singleton variable.

Example:

member(X,[X|T]).

member(X,[X|         


        

Answer 1

Singleton variables are useless in Prolog, and are easily introduced by editing typos.

The warning is welcome to me, as it allows to easily spot such frequent cause of error.

Being a warning, you can run code containing singletons, but any value these eventually will assume will be lost.

I don't think that ISO standard (never heard about ANSI) forbids such variables.

You could rewrite your example in this way

member(X, [Y|T]) :- X = Y ; member(X, T).

and then forget about the singleton.

Answer 2

You can read about it on the official page of SWI-Prolog FAQ

The most common cases this warning appears are:

1. Spelling mistakes in variables
2. Forget to use/bind a variable

SWI suggest some ways to ignore it:

1. Use anonymous variable named _ for this purpose.
2. Use your variable starting with _ (like _T, _X), to avoid warning and document what you ignore.
3. If you are aware of what you are doing, you can use :- style_check(-singleton). and all warnings should go away.

Answer 3

You have a bug here:

member(X,[X|T]) :- member(X,T).

What you're actually saying (as opposed to what you think you're saying) is that member/2 holds if X is at the head of the list and present in the tail of the list. This predicate will only ever be true for the first N copies of the same thing at the beginning of a list, so it's a very strange thing to say!

?- member(X, [a,a,c]).
X = a ;
X = a ;
false.

?- member(X, [b,a,a]).
X = b ;
false.

Now, you could correct the bug and still have a singleton warning by doing something like this:

member(X, [Y|T]) :- member(X, T).

But this is neither as good as the conventional definition with two heads or @CapelliC's version (+1) with an explicit OR. I think you should wait until you understand Prolog a little better before putting much stock in your sense of Prolog code aesthetics. If you stick with it for a while you'll come to appreciate this warning as well as the use of anonymous variables.

What makes singleton variables useless in Prolog is that they're named but nothing is known about them and they have no effect on the rest of the computation. The underscore highlights that absolutely anything could go in there without affecting the meaning. What makes

member(X, [X|T]).

true is that the X is position 1 is the same as the X at the head of the list in position 2. Lists must either be empty or have a head and a tail, but what's in the tail is not relevant here, what matters is that X is also the head. The T could be the rest of the list, or it could be an improper list, or it could be a breadbox or lightning or the smell of the air on a spring day. It has no bearing on the truth of member(X, [X|T]).

The singleton warning tells you "you've reserved a name for something here, but you never call anything by that name." The first thing I do when I get this message and it isn't an obvious typo is replace the name with _ and see if my code still makes sense. If it doesn't, I have a logic error. If it does, it was probably unnecessary.