Question

I wrote a bubble sort in Prolog (code below). It works but it smells. I’m quite new to prolog. Here’s the problematic part:

% Problem: convert the true value to something
% I can actually use.
sorted_value(X,X) :- sorted(X).
sorted_value(X,[]) :- not(sorted(X)).

It’s weird I need to use this function to convert a True value to something (in this case, []) and False to another thing in order to use them. Isn’t there a cleaner way?

% Bubble Sort a list.

% is the list sorted?
sorted([]).
sorted([Head|[]]).
sorted([First|[Second|Rest]]) :-
  min(First,Second,First),
  sorted([Second|Rest]).

% swap all pairs in the list that
% needs to be swapped
bubble_sort_list([], []).
bubble_sort_list([Head|[]],[Head]).
bubble_sort_list([First|[Second|Rest]], [One|Solution]) :-
  min(First,Second, One),
  max(First,Second,Two),
  bubble_sort_list([Two|Rest],Solution).

% Problem: convert the true value to something
% I can actually use.
sorted_value(X,X) :- sorted(X).
sorted_value(X,[]) :- not(sorted(X)).

% Repeatedly call bubble_sort until
% the list is sorted
bubble_sort_helper([],List, Solution) :-
  bubble_sort_list(List, SortedList),
  sorted_value(SortedList, Value),
  bubble_sort_helper(Value,SortedList, Solution).
bubble_sort_helper(A,List,List).

% this is what you call.
buuble_sort(List,Solution) :-
  bubble_sort_helper([],List,Solution).

Answer 1

Every predicate call either succeeds (possibly several times) or fails. If you think declaratively and really describe what a sorted list is, there would only rarely seem to be a need to explicitly represent the truth value itself in a program. Rather, it would typically suffice to place a predicate call like “ascending(List)” in a Prolog program to describe the case of a sorted list. There seems to be no advantage to instead call a predicate like “ascending(List, T)” and then use T to distinguish the cases. Why not use the implicit truth value of the predicate itself directly? If you really need to reify the truth value, you can for example do it like this to avoid calling ascending/1 twice:

ascending(Ls, T) :- 
    (   ascending(Ls) -> T = true
    ;   T = false
    ).

Notice how the truth of ascending/1 is used to distinguish the cases.