call
call is a built-in meta-predicate that allows its single
argument to be called/invoked as a goal. For
example, a program might create a goal (perhaps using
=..) on the fly, and then,
presumably later in the program, need to test the goal.
Here are queries that perform these roles - in a real
program, both the assert and the call
would be built in to Prolog procedures written by the programmer.
?- assert(likes(mary, pizza)). ?- call(likes(Person, pizza)). Person = mary ?- Goal =.. [likes, mary, What], call(Goal). Goal = likes(mary, pizza) What = pizza
."). A clause
may be a fact, like:likes(mary, pizza). food(pizza).
or a rule, like:
eats(Person, Thing) :- likes(Person, Thing), food(Thing).
A clause may also be a query to the Prolog interpreter, as in:
?- eats(mary, pizza).
A group of clauses about the same relation is termed a procedure.
%. Comments are ignored by the Prolog
interpreter; their purpose is to help a human reader understand
the Prolog code. Examples:
% This is a full line comment. % The next line contains a part-line comment. member(Item, [Item|Rest]). % member succeeds if Item is 1st object in list.
Commenting Guidelines
As in other programming languages, comments should be used freely to explain the high-level significance of sections of code, to explain tricky sections of code, etc. Comments should not echo what the code already clearly says. Comments like that actually get in the way of understanding, for example because they are likely to make the reader ignore the comments. Where it is possible to make code understandable by using a meaningful functor name or variable name, this is preferable to a comment.
It is good practice to begin each Prolog procedure with a comment describing what it does, e.g.
% member(Item, List) - succeeds if the item is a member of the list
If the list needs to have some special properties, e.g. if it must be a list of numbers, or must be instantiated (that is, have a value) at the time the procedure is called, then this header comment should say so:
% member(Item, List) - succeeds if the item is a member of the list; % List must be instantiated at the time member is called. Item need not % be instantiated.
It can be a good idea for the header comments to indicate examples of the kind of data on which the procedure is intended to operate, and what the result should be, if this can be done reasonably briefly. E.g.
% Examples of use: % ?- member(b, [a, b, c]). % true. % % ?- member(X, [a, b, c]). % X = a ; % X = b ; % X = c ; % fail.
Each file of Prolog code should begin with a (file) header comment, indicating who wrote the code, when, and what it is (overall) intended to do. This would be enough in a short Prolog assignment. In a "industrial strength" Prolog system, there would be details on the origins of algorithms used, and a revision history.
A good source of examples of Prolog commenting is example code made available in class, such as this one. Note however that this one is rather more heavily commented than usual, for instructional purposes. Note also that code examples presented on screen may be under-commented, because of the difficulty of fitting the comments and the code on the screen, and because the oral presentation accompanying the on-screen material replaces the comments to some extent.
Don't make your lines of comments (or code) too long - long lines can be hard to read, and really long lines may be folded, turning your neat formatting into a dog's breakfast. Stick to a maximum line length of 70 or 80 characters. Cute lines and/or boxes constructed of comment characters have the side effect of preventing the reader from seeing as much of your code at one time. The reader may then have to page up and down to figure out what your code does. They will not like you for this.
The use of cuts should normally be commented to explain why the cut is necessary.
It is a bad idea to comment (almost) every line, partly because of the clutter, and the distraction that this causes, and partly because most such comments are pointless duplications of the code (and/or comment things obvious except to a novice Prolog programmer):
Example of bad commenting (every line commented):
factorial(0, 1). % Factorial of 0 is 1.
factorial(N, FactN) :-
N > 0, % N is positive
Nminus1 is N - 1, % Calculate N minus 1
factorial(Nminus1, FactNminus1), % recursion
FactN is N * FactNminus1. % N! = N * (N - 1)!
Of these comments, only the first and last are even faintly justifiable,
and even these are probably too obvious, as, particularly for the last
comment, the variable names tell you everything you need to know. It looks
pretty, with all the %-signs neatly lined up, but it forces
the reader to check through all the unnecessary comments in case there
is anything important there. This code needs a header code, and probably
nothing else, though a beginning Prolog programmer might be justified
in pointing out that the line N > 0, is there to make
sure that the rule is only used in the case where N is
positive. (If you're not sure why this is so important, try leaving out
N > 0, and test the function on say N = 2.)
So the comment would be "% only use rule if N > 0.
How to write even worse comments!
It's easy - just write comments that are actually wrong.
Review your comments in a cool moment, and make sure that
what they say is true.
The + - ? convention for arguments to procedures
A convention often used to make the role of arguments to
a procedure clearer is to tag them with +,
–, and ?, as follows:
| Tag | Meaning |
|---|---|
+ | argument is expected to be instantiated (i.e. have a value rather than be a variable) when the procedure is called as a goal. |
– | argument is expected to be a variable to be bound when the procedure is called as a goal. |
? | argument may be either instantiated, or be a variable, when procedure is called as a goal. |
Example:
% factorial(+N, -FactorialN). %% supply a value for N, and FactorialN will be computed. % member(?Item, ?List). %% Item and List may either be instantiated, or a variable %% (but in fact at least one of them must be instantiated!)It's worth checking out, by the way, what happens if
List
is not instantiated …
?- member(a, List). List = [a|_G231] ; List = [_G230, a|_G234] ; List = [_G230, _G233, a|_G237]and so on … Prolog works its way through all list structures that contain
a.
Spelling, grammar, etc.
It's no bad thing if all of these comments are spelled correctly and are grammatically phrased. (Sometimes it is appropriate to abbreviate, so perhaps your comments don't all need to be full sentences.) It makes life harder for folks trying to read your code, if they have to wade through poor spelling and grammar. Remember that the people reading your code will include people you will want to understand your comments easily - helpers, markers, colleagues, your boss, even yourself in a year's time when you've forgotten how you got the code to work … So get into good commenting habits from the start.
See also indentation and white space.
| Comparison | Definition | Evaluates? |
|---|---|---|
X = Y | succeds if X and Y unify (match) in the Prolog sense | No |
X \= Y | succeeds if X and Y do not unify; i.e. if not (X = Y) | No |
T1 == T2 | succeeds if terms T1 and T2 are identical; e.g. names of variables have to be the same | No |
T1 \== T2 | succeeds if terms T1 and T2 are not identical | No |
E1 =:= E2 | succeeds if values of expressions E1 and E2 are equal | Yes |
E1 =\= E2 | succeeds if values of expressions E1 and E2 are not equal | Yes |
E1 < E2 | succeeds if numeric value of expression E1 is < numeric value of E2 | Yes |
E1 =< E2 | succeeds if numeric value of expression E1 is ≤ numeric value of E2 | Yes |
E1 > E2 | succeeds if numeric value of expression E1 is > numeric value of E2 | Yes |
E1 >= E2 | succeeds if numeric value of expression E1 is ≤ numeric value of E2 | Yes |
T1 @< T2 | succeeds if T1 is alphabetically < T2 | No |
T1 @=< T2 | succeeds if T1 is alphabetically ≤ T2 | No |
T1 @> T2 | succeeds if T1 is alphabetically > T2 | No |
T1 @>= T2 | succeeds if T1 is alphabetically ≥ T2 | No |
See also is. is is not
a comparison operator, but is frequently confused with = by
novice Prolog programmers. Briefly, you use X is Exp
to evaluate an arithmetic expression, like Y + 2,
that contains an arithmetic operator, like +, and
bind the resulting value to the variable X to the left of the
the operator is.
As an example of @< and its relatives,
?- likes(mary, pizza) @< likes(mary, plums). true.This succeeds because
likes and mary are
the same in both terms, and pizza alphabetically
precedes plums.
Comparison of fractional numbers: When comparing two
fractional numbers, problems can arise from the approximate
nature of representations of fractional numbers in computers.
Sometimes it will work as expected, and sometimes not.
For example, the query 1.21 =:= 1.1 * 1.1. fails
with SWI Prolog on the computer where this article was written.
You can and should work around this problem by, instead of
testing fractional numbers for equality, doing something
like the following:
?- abs(1.21 - 1.1 * 1.1) < 0.000001. true.
abs signifies "absolute value":
abs(X) = X if X >= 0 and
abs(X) = -X if X =< 0.More generally, test for
abs(X - Y) < Tiny, where
Tiny is bound to small number (or is a small number, as in
the example).
How small to make Tiny above depends on the particular
case - you might need to use a smaller number if X and
Y need to be very close together to make your
algorithm work correctly.
consult
?- consult('myprogram.pl').
This loads the contents of the Prolog program in the file
myprogram.pl into the running Prolog's database.
Note that in SWI Prolog, at least, before loading the new facts
and rules into the database, Prolog first removes all facts
and rules that relate to procedures in myprogram.pl.
So if myprogram.pl contains, for example, the
fact likes(jane, pizza) then all facts and rules
about likes that have two arguments will be removed
from the Prolog database before the new facts in
myprogram.pl are loaded up. This is convenient
when you are using consult to re-load a program
after editing it (e.g. in another window, with the Prolog
interpreter left running), but could be a little surprising
if you were trying to load extra facts from a file.
It is possible to consult more than one file at a time, by replacing the single file name with a list of files:
?- consult(['file1.pl', 'file2.pl', 'file3.pl']). % file1.pl compiled 0.00 sec, 524 bytes % file2.pl compiled 0.01 sec, 528 bytes % file3.pl compiled 0.00 sec, 524 bytes true.It is also possible to abbreviate a consult call, simply typing the list of (one or more) files as a goal for Prolog:
?- ['file1.pl', 'file2.pl', 'file3.pl'].In some Prolog implementations, consulting
user causes the
Prolog interpreter to read facts and rules from the user's
terminal:
?- [user]. |: likes(jane, pizza). |: bad_dog(Dog) :- |: bites(Dog, Person), |: is_human(Person), |: is_dog(Dog). |: <control-D> % user://1 compiled 0.00 sec, 1,156 bytes true. ?-
However, you might wish to get input/read from somewhere else
during the execution of your Prolog program - for example,
you might want to read from a file held on the computer on
which the program is running, or on some local file server.
To change the current input stream, you use the Prolog
built-in extra-logical predicate see. If Prolog
executes the goal see('input.dat'), then input will subsequently
come from the file input.dat, in the current working directory
of the workstation*
that is running Prolog. If the specified file cannot be found in the
current working directory, an error may be reported,
as in this interaction with SWI Prolog:
?- see('nosuchfile.dat').
ERROR: see/1: source_sink `nosuchfile.dat' does not exist (No such file or directory)
Other errors are possible - you may not have the right to read
the file in question, for example.
If the file does exist and is readable, then subsequent read operations
get their data from the file. The parameter to see can be
just the file name, as illustrated above, or it could be
a path to the file that is wanted: e.g.
see('/Users/billw/prologstuff/input.dat')
Prolog will continue to issue prompts for more queries while
you are "seeing" a file, but any explicit read operations
access the file.
The built-in extra-logical predicate seen (with no argument)
allows you to revert to reading data from the keyboard.
Example (assuming info.dat starts with the line
hungry(jack).):
?- see('info.dat'), read(X).
X = hungry(jack)
?- seen, read(Y).
|: full(jack).
Y = full(jack)
See also current output stream, input, output, files.
However, you might wish to write to somewhere else during the execution of your Prolog program - for example, you might want to write to a file held on the computer on which the program is running, or on some local file server.
To change the current output stream, you use one of the Prolog
built-in extra-logical predicates tell and
append/11.
If Prolog executes the goal tell('output.dat'), then output
will subsequently go to the file output.dat,
in the current working directory of the
workstation2
that is running Prolog.
If the specified file cannot be found in the
current working directory, it will be created. If the file does exist, it will
be overwritten. If you use append/1, subsequent
write operations will add material to the end of the file,
instead of overwriting the file. If you do not have permission
to write files in the current directory, you will see an error
message:
?- tell('/usr/bin/ztrash').
ERROR: tell/1: No permission to open source_sink `/usr/bin/ztrash' (Permission denied)
This means that you do not have permission to write files in
the directory /usr/bin. Another possible error is
that you might not have permission to write to the particular
file, if it already exists.
If the file is able to be written, then subsequent write operations
send their data to the file. The parameter to tell can be
a path to the file that is wanted, as in the example above, or it
could be just the file name, e.g.
tell('output.dat').
Prolog will continue to issue prompts for more queries and
print bindings while you are "telling" or "appending" a file,
but any explicit write operations access the file.
The built-in extra-logical predicate told (with no argument)
allows you to revert to writing data to the original window.
Example:
?- tell('info.dat'), write(thirsty(jack)), nl.
true.
?- told, write(drunk(jack)).
drunk(jack)
true.
?- halt.
% cat info.dat # - # is Unix comment char, cat lists info.dat
thirsty(jack)
%
See also current input stream, input, output, files.
-
append/1is not related toappend/3, which in turn has nothing to do with output streams.
!, which always succeeds, but cannot be backtracked past. It is used to prevent unwanted
backtracking, for example, to prevent extra solutions being found by
Prolog.The cut should be used sparingly. There is a temptation to insert cuts experimentally into code that is not working correctly. If you do this, bear in mind that when debugging is complete, you should understand the effect of, and be able to explain the need for, every cut you use. The use of a cut should thus be commented.
Example: Suppose we have the following facts:
teaches(dr_fred, history). |
studies(alice, english). |
Then consider the following queries and their outputs:
?- teaches(dr_fred, Course), studies(Student, Course). Course = english Student = alice ; Course = english Student = angus ; Course = drama Student = amelia ; fail.
Backtracking is not inhibited here. Course is
initially bound to history, but there are no students
of history, so the second goals fails, backtracking
occurs, Course is re-bound to english, the
second goal is tried and two solutions found (alice
and angus), then backtracking occurs again, and
Course is bound to drama, and a final
Student, amelia, is found.
?- teaches(dr_fred, Course), !, studies(Student, Course). fail.
This time Course is initially bound to history,
then the cut goal is executed, and then studies goal
is tried and fails (because nobody studies
history). Because of the cut, we cannot
backtrack to the teaches goal to find
another binding for Course, so the whole query
fails.
?- teaches(dr_fred, Course), studies(Student, Course), !. Course = english Student = alice ; fail.
Here the teaches goal is tried as usual, and
Course is bound to history, again as
usual. Next the studies goal is tried and fails,
so we don't get to the cut at the end of the query at this point,
and backtracking can occur. Thus the teaches goal is
re-tried, and Course is bound to english.
Then the studies goal is tried again, and succeeds, with
Student = alice. After that, the cut goal is
tried and of course succeeds, so no further backtracking is possible
and only one solution is thus found.
?- !, teaches(dr_fred, Course), studies(Student, Course). Course = english Student = alice ; Course = english Student = angus ; Course = drama Student = amelia ; fail. ?-
In this final example, the same solutions are found as if no cut was present, because it is never necessary to backtrack past the cut to find the next solution, so backtracking is never inhibited.
Cuts in Rules
In practice, the cut is used in rules rather than in multi-goal
queries, and some particular idioms apply in such cases.
For example, consider the following code for
max(X, Y, Max), which is supposed to bind Max to
the larger of X and Y (which are assumed to be numbers).
max(X, Y, X) :- X > Y, !. max(X, Y, Y).This is a way of saying: "if the first rule succeeds, use it and don't try the second rule. (Otherwise, use the second rule.) We could instead have written:
max(X, Y, X) :- X > Y. max(X, Y, Y) :- X =< Y.in which case both rules will normally be tried (unless backtracking is prevented by a cut in some other part of the code). This is slightly less efficient if
X
is in fact greater than Y (unnecessary backtracking
occurs) but easier for people to understand, though regular
Prolog programmers rapidly get to recognise this type of
idiom. The extra computation in the case of max is
trivial, but in cases where the second rule involves a long computation,
there might be a strong argument for using the cut on efficiency
grounds.
