Prolog: Creating a frequency list of another list - prolog

Question

So, I've written a program that reads input from a .txt file in the form of 2 integers and a list of integers: the first integer is the length of the list, the second is the number of different elements, and the list is the list in question.
I then want to create a list of frequencies for the elements, like so:
List = [1, 2, 3, 1, 3, 2, 3, 1],
FreqList = [3, 2, 3].
Here is my code:
% Create random list
createList(List) :-
length(List, 10),
maplist(random(0,4), List).
% Count the frequency of an element:
countElement(_, [], 0) :- !.
countElement(_, [], _).
countElement(Element, [Element|Tail], Counter) :-
countElement(Element, Tail, Counter2),
Counter is Counter2 + 1.
countElement(Element, [_|Tail], Counter) :-
countElement(Element, Tail, Counter).
% Create frequency list:
createFreqList(_, _, Numbers, [], CurrentNumber) :-
Numbers = CurrentNumber.
createFreqList(List, Length, Numbers, [Head|Tail], CurrentNumber) :-
Numbers \= CurrentNumber,
countElement(CurrentNumber, List, Head),
CurrentNumber2 is CurrentNumber + 1,
createFreqList(List, Length, Numbers, Tail, CurrentNumber2).
frequency(List, FreqList) :-
createList(List),
Numbers2 is 4,
createFreqList(List, 10, Numbers2, FreqList, 1).
So, on first execution the program runs ok, and it outputs the correct frequency list. However, if I input ';', instead of giving me 'false' it runs again, outputing a wrong frequency list, and that just repeats for as long as I press ';'.

Answer 1

I would probably do something like this:
frequencies(Xs, Fs) :-
msort(Xs,Sorted),
glob( Sorted, [], Fs ).
glob( [], Fs, Fs ).
glob( [X|Xs], [X:N|Ts], Fs ) :-
!,
N1 is N+1,
glob(Xs, [X:N1|Ts], Fs ).
glob( [X|Xs], Ts, Fs ) :-
glob(Xs, [X:1|Ts], Fs).
That used msort/2 to put the list in sequence.The resulting list is in descending sequence by key value — [ 3:123, 2:25, 1:321 ].
You could also do something like this:
frequencies(Xs, Fs) :- frequencies( Xs, [], Fs ).
frequencies( [], Fs, Fs ).
frequencies( [X|Xs], Ts, Fs ) :-
tote( X, Ts, T1),
frequencies(Xs, T1, Fs).
tote( X, Ts, Fs ) :-
append( Pfx, [X:N|Sfx], Ts),
!,
N1 is N+1,
append( Pfx, [X:N1|Sfx], Fs).
tote( X, Ts, [X:1|Ts] ).
I suspect that a one-time sort of the original list is probably going to be faster than repeated scans of the accumulator list.

Answer 2

Just in case you don't want to reinvent the wheel.
There is a quasi standard called library(aggregate). But library(aggregate) can be also implemented on top of the ISO core standard bagof/3, which also gets you there:
Welcome to SWI-Prolog (threaded, 64 bits, version 8.1.6)
?- aggregate(count, member(X,[1, 2, 3, 1, 3, 2, 3, 1]), R).
X = 1,
R = 3 ;
X = R, R = 2 ;
X = R, R = 3.
?- bagof(hit, member(X,[1, 2, 3, 1, 3, 2, 3, 1]), L), length(L, R).
X = 1,
L = [hit, hit, hit],
R = 3 ;
X = R, R = 2,
L = [hit, hit] ;
X = R, R = 3,
L = [hit, hit, hit].
Or in another Prolog system:
Jekejeke Prolog 3, Runtime Library 1.3.7 (May 23, 2019)
?- use_module(library(advanced/aggregate)).
% 3 consults and 0 unloads in 110 ms.
Yes
?- use_module(library(basic/lists)).
% 0 consults and 0 unloads in 0 ms.
Yes
?- aggregate(count, member(X,[1, 2, 3, 1, 3, 2, 3, 1]), R).
X = 1,
R = 3 ;
X = 2,
R = 2 ;
X = 3,
R = 3
?- bagof(hit, member(X,[1, 2, 3, 1, 3, 2, 3, 1]), L), length(L, R).
X = 1,
L = [hit,hit,hit],
R = 3 ;
X = 2,
L = [hit,hit],
R = 2 ;
X = 3,
L = [hit,hit,hit],
R = 3