Additional Features of Prolog
and the ISO Standard

Slide 2 — The ISO Prolog standard

Prolog is a real, practical programming language based on that paradigm — the most popular one, and standardized by ISO. What does it add?

A fixed control. By default the search rule is depth-first and the computation rule is left-to-right. You no longer choose; the language has chosen for you. That is a loss of generality, and it buys a great deal: a program with a fixed, known execution order can be compiled into fast code — including native code — and then it runs at roughly the speed of any other language.

A large library of built-in predicates. Some declarative, some not — but all of them efficient. Arithmetic is the obvious case: built-in integer arithmetic is enormously faster than the Peano arithmetic we wrote in the previous part.

Things that go beyond first-order logic. Higher-order predicates; meta-logical predicates, which can ask whether something is still a variable — a question you cannot even state in pure logic; and modification of the program itself while it runs, programs that rewrite themselves as they go.

Slide 3 — An overview of the standard

That list is also the plan of this part of the course, and of these notes.

If we stopped at the previous slide we would already have most of the difference between Prolog and pure logic programming — at least for pure Prolog programs, where the differences are that it runs depth-first and that this lets you control the search. Everything below is what the ISO standard adds on top. Other systems have plenty more, but those extensions are system-specific; the standard is what everyone agrees on.

Slide 4 — The programming interface

For the system used in this course, see the separate part on Developing Programs with a Logic Programming System.

Slide 5 — Prolog syntax and terminology

There are some new data types.

Numbers — real numbers now, not Peano numbers: 0, 999, -77, 5.23, 0.23e-5. And a very nice property of many current systems, Ciao among them: integers have infinite precision. There is no word size, and no overflow.

?- X is 1234567890123456789012345678901234567890 * 987654321.

X = 1219326311248285321124828532112482853211126352690 ?

?- X = "foo".

X = [102,111,111] ?

?- set_prolog_flag(write_strings, on), X = "foo".

X = "foo" ?

Comments are % to the end of the line, or /* ... */ as in C.

Slide 6 — Defining operators

The declaration is

:- op(<precedence>, <type>, <operator(s)>).

Type is one of nine mnemonics, and they read as pictures — f is the operator, x and y are the arguments:

• infix: xfx (not associative), xfy (right associative), yfx (left associative)
• prefix: fx (non-associative), fy (associative)
• postfix: xf (non-associative), yf (associative)

Operators is a single atom or a list of atoms.

?- write_canonical(1+2/4^2), nl.

+(1,/(2,^(4,2)))

Slide 7 — Operators in use

:- module(_,_,[]).

:- op(500, xfx, is_father_of).

john  is_father_of peter.
peter is_father_of jim.

?- is_father_of(X, Y).

X = john,
Y = peter ?

?- op(500, xfx, is_father_of).

yes
?- X is_father_of Y.

X = john,
Y = peter ?

Which brings us to the point of the slide:

Look at the last two lines. A clause is a term: the principal functor is :-, the neck; the first argument is the head; the second is the body, which for a conjunction is the term ','(q(Y),r(Z)) — nested to the right, exactly like the dots of a list.

One syntactic trap. Parentheses must be used around operators whose priority is higher than 1000, the priority of ,. So you write ..., assert( (p :- q) ), ... — without the inner parentheses the comma-separated argument list wins and you get a syntax error.

Slide 8 — The standard operator table

:- op( 1200, xfx, [ :-, --> ]).
:- op( 1200,  fx, [ :-, ?- ]).
:- op( 1150,  fx, [ mode, public, dynamic,
                    multifile, block, meta_predicate,
                    parallel, sequential ]).
:- op( 1100, xfy, [ ; ]).
:- op( 1050, xfy, [ -> ]).
:- op( 1000, xfy, [ ',' ]).
:- op(  900,  fy, [ \+, spy, nospy ]).
:- op(  700, xfx, [ =, is, =.., ==, \==, @<, @>, @=<, @>=,
                                =:=, =\=, <, >, =<, >= ]).
:- op(  550, xfy, [ : ]).
:- op(  500, yfx, [ +, -, #, /\, \/ ]).
:- op(  500,  fx, [ +, - ]).
:- op(  400, yfx, [ *, /, //, <<, >> ]).
:- op(  300, xfx, [ mod ]).
:- op(  200, xfy, [ ^ ]).

Slide 9 — The execution mechanism of classical Prolog

• Always execute the calls in the body of a clause left to right.
• On entering a procedure, if several clauses unify — a choice point — take the first unifying clause, that is, the leftmost unexplored branch.
• On failure, backtrack to the next unexplored clause of the last choice point.

:- module(_, _).

grandparent(C,G) :-
    parent(C,P),
    parent(P,G).

parent(C,P) :- father(C,P).
parent(C,P) :- mother(C,P).

father(charles, philip).
father(ana, george).

mother(charles, ana).

?- grandparent(charles, X).

X = george ?

Slides 10–12 — Built-in arithmetic

The type of arithmetic terms. It is defined exactly the way we defined types in the pure part:

• a number is an arithmetic term;
• if f is an n-ary arithmetic functor and X1,...,Xn are arithmetic terms, then f(X1,...,Xn) is an arithmetic term.

Slide 11 gives the type itself, and it is worth looking at as a type: a long but perfectly ordinary recursive definition, in the same shape as nat/1 or list/1, where every alternative but the first is built from smaller arithmetic expressions. Its real name in Ciao is arithexpression/1 (core/engine/arithmetic.pl defines it); the slide — and the definition below — write arithexpr for short, to fit.

arithexpr :=
    | num
    | + arithexpr           | - arithexpr
    | ++ arithexpr          | -- arithexpr
    | arithexpr + arithexpr | arithexpr - arithexpr
    | arithexpr * arithexpr | arithexpr // arithexpr
    | arithexpr / arithexpr | abs(arithexpr)
    | sign(arithexpr)       | float_integer_part(arithexpr)
    | float(arithexpr)      | float_fractional_part(arithexpr)
    | arithexpr ** arithexpr| exp(arithexpr)
    | log(arithexpr)        | sqrt(arithexpr)
    | sin(arithexpr)        | cos(arithexpr)
    | atan(arithexpr)       | [arithexpr]
    | ...

Beyond those there are rem, mod, gcd, the shifts and the bitwise operators, and integer, truncate, floor, round, ceiling. The manuals have the complete list.

?- X = 3+4/2, write_canonical(X), nl.

+(3,/(4,2))

X = 3+4/2 ?

The two things you can do with an arithmetic term are evaluate it and compare it.

Z is X evaluates X — which must be an arithmetic term — and unifies the result with Z. The comparison operators <, >, =<, >=, =:= (arithmetic equality) and =\= (arithmetic inequality) evaluate both arguments and compare the results.

?- X is 3*3//2.

X = 4 ?

?- Z = 3//2, X is 3+Z.

X = 4,
Z = 3//2 ?

?- X = 1 + Y, Y = 3/2, Z is X.

X = 1+3/2,
Y = 3/2,
Z = 2.5 ?

?- X=3, Y=4, Y < X+1.

no

?- X=3, Y=4, X is Y+1.

no

?- Y=4, Y < a+1.

{ERROR: arithmetic:is/2, arg 2 - expected an arithmetically evaluable
 expression, found /(a,0)}

?- X is Z+1.

{ERROR: arithmetic:is/2, arg 2 - argument is not sufficiently instantiated}

?- X=3, X =:= f(a).

{ERROR: arithmetic:=:=/2, arg 2 - expected an arithmetically evaluable
 expression, found /(f,1)}

Slide 13 — Arithmetic programs

plus(X,Y,Z) :- Z is X + Y.

Factorial makes the trade visible. Here are both versions side by side:

:- module(_,_).

% a) Using Peano arithmetic:

peano_factorial(0,s(0)).
peano_factorial(s(N),F) :-
    peano_factorial(N,F1),
    peano_times(s(N),F1,F).

peano_times(0,_,0).
peano_times(s(X),Y,Z) :-
    peano_times(X,Y,W),
    peano_plus(W,Y,Z).

peano_plus(0,Y,Y) :- nat(Y).
peano_plus(s(X),Y,s(Z)) :- peano_plus(X,Y,Z).

nat(0).
nat(s(X)) :- nat(X).

% b) Using ISO-Prolog is/2 and >/2:

factorial(0,1).
factorial(N,F) :-
    N > 0,
    N1 is N-1,
    factorial(N1,F1),
    F is F1*N.

?- factorial(7,F).

F = 5040 ?

wrong_factorial(0,1).
wrong_factorial(N,F) :-
    N > 0,
    N1 is N-1,
    F is F1*N,              % F1 has no value yet!
    wrong_factorial(N1,F1).

?- wrong_factorial(3,F).

{ERROR: arithmetic:is/2, arg 2 - argument is not sufficiently instantiated}

?- factorial(N,6).

{ERROR: arithmetic:>/2, arg 1 - argument is not sufficiently instantiated}

Slide 14 — Dynamic checking of basic types

They are unary relations that check the type of a term:

• integer(X)
• float(X)
• number(X)
• atom(X) — a non-variable term of arity 0 other than a number
• atomic(X) — an atom or a number

They behave as if defined by a (possibly infinite) table of facts — integer(1). integer(2). … — and they either succeed or fail; they never raise an error.

?- integer(1).

yes

?- integer(1.0).

no

?- integer(X).

no

?- X = 1, integer(X).

X = 1 ?

?- integer(X), X = 1.

no

Slide 15 — Recovering some reversibility

plus(X,Y,Z) :- Z is X + Y.

:- module(_,_).

plus(X,Y,Z) :- Z is X + Y.

plus2(X,Y,Z) :- number(X), number(Y), Z is X + Y.
plus2(X,Y,Z) :- number(X), number(Z), Y is Z - X.
plus2(X,Y,Z) :- number(Y), number(Z), X is Z - Y.

?- plus2(4,5,Z).

Z = 9 ?

?- plus2(X,5,9).

X = 4 ?

?- plus2(X,Y,9).

no

Slide 16 — Structure inspection with functor

• given X = f(X1,...,Xn), it gives F = f and A = n;
• given the atom f and the integer n, it builds X = f(_,...,_) with n fresh arguments.

?- functor(t(b,a), F, A).

A = 2,
F = t ?

?- functor(Term, f, 3).

Term = f(_,_,_) ?

Slide 17 — Structure inspection with arg

?- T = date(9,'February',1947), arg(3,T,X).

T = date(9,'February',1947),
X = 1947 ?

Building and filling in one go:

?- functor(Array,array,5), arg(1,Array,black), arg(5,Array,white).

Array = array(black,_,_,_,white) ?

?- arg(2, [a,b,c,d], X).

X = [b,c,d] ?

Slides 18–19 — Example: arrays

:- module(_,_).

add_arrays(A,B,C):-
    functor(A,array,N), % gets length N from array A
    functor(B,array,N), % checks that B has the same length
    functor(C,array,N), % creates C to hold the result
    add_elements(N,A,B,C).

add_elements(0,_A,_B,_C).
add_elements(I,A,B,C):-
    I>0,
    arg(I,A,AI),
    arg(I,B,BI),
    arg(I,C,CI),
    CI is AI + BI,
    I1 is I - 1,
    add_elements(I1,A,B,C).

% Alternative, using lists instead of structures:

add_lists([],[],[]).
add_lists([X|Xs],[Y|Ys],[Z|Zs]):-
    Z is X + Y,
    add_lists(Xs,Ys,Zs).

?- add_arrays(array(1,2,3), array(4,5,6), R).

R = array(5,7,9) ?

• functor(A,array,N): A is instantiated, so this checks the principal functor is array and reads the arity into the free N.
• functor(B,array,N): now N is bound, so this checks that B has the same length. That coincidence of variable is the whole length check.
• functor(C,array,N): C is free but array and N are bound, so functor/3 runs backwards and creates the result array — length N, full of holes.

Mismatched lengths simply fail:

?- add_arrays(array(1,2,3), array(4,5), R).

no

?- add_arrays(array(1,2,3),A2,array(5,7,9)).

{ERROR: arithmetic:is/2, arg 2 - argument is not sufficiently instantiated}

Slide 19 (contd.) — Syntactic sugar for arg

:- module(_,_).

:- use_package(fsyntax).  % use functional notation
:- op(250,xfx,@).         % define @ as an infix operator
T@N := A :- arg(N,T,A).   % define @ to call arg/3
:- fun_eval @ / 2.        % evaluate all occurrences of @/2
array(A,N) :- functor(A,array,N).
:- fun_eval arith(true).  % evaluate arithmetic expressions (I-1)

add_arr(A,B,C):-
    array(A,N),
    array(B,N),
    array(C,N),
    add_els(N,A,B,C).

add_els(0,_,_,_).
add_els(I,A,B,C) :-
    I>0,
    C@I is A@I + B@I,
    add_els(I-1,A,B,C).

?- add_arr(array(1,2,3), array(4,5,6), R).

R = array(5,7,9) ?

And nothing forces @. Declare sub as an xfx operator and write a sub 3; or use : and write a:3. With functional notation you can go further and chain them — a sub 3 sub 2 reads element (3,2) of a matrix — because the syntax is extensible and you decide how convenient you want it to be.

Slide 20 — Example: subterms of a term

:- module(_,_).

subterm(Term,Term).   % a) a term is always a subterm of itself
subterm(Sub,Term):-   % b) the arguments are also subterms:
    nonvar(Term),     %    check Term is not a free variable
    functor(Term,_F,N),%   N is the number of arguments of Term
    n_to_one(N, J),   %    J is a natural between N and 1
    arg(J,Term,Arg),  %    Arg is the J-th argument of Term
    subterm(Sub,Arg). %    Sub is a subterm of Arg

n_to_one(N, N) :- N > 0.
n_to_one(N, X) :- N > 1, N1 is N-1, n_to_one(N1, X).

?- subterm(f(a), g(b,f(a))).

yes

?- subterm(f(b), g(b,f(a))).

no

?- subterm(X, g(b,f(a))).

X = g(b,f(a)) ? ;
X = f(a) ? ;
X = a ? ;
X = b ? ;
no

Slide 21 — Higher-order structure inspection: univ

?- date(9,february,1947) =.. L.

L = [date,9,february,1947] ?

The interesting direction is backwards — from a list of pieces, build a term:

?- F = '+', X =.. [F,a,b].

F = +,
X = a+b ?

?- F = '+', X =.. [F,3,5], Z is X.

F = +,
X = 3+5,
Z = 8 ?

:- module(_,_).

deriv(sin(X), X, cos(X)).
deriv(cos(X), X, -sin(X)).
% Chain rule:
deriv(FG_X,   X, DF_G * DG_X):-
    FG_X =.. [_, G_X],
    deriv(FG_X, G_X, DF_G),
    deriv(G_X, X, DG_X).

?- deriv(sin(cos(x)), x, D).

D = cos(cos(x))* -sin(x) ?

Slide 22 — Strings, atoms, and creating new atoms

?- name(hello, S).

S = [104,101,108,108,111] ?

?- name(A, "hello").

A = hello ?

Backwards, name/2 creates atoms out of nothing — and combined with univ that means creating new functors, and therefore new structures, at run time:

?- name(N, "foo"), T =.. [N,b,c].

N = foo,
T = foo(b,c) ?

?- X='1', atom(X), name(X,S), name(Y,S), number(Y).

S = [49],
X = '1',
Y = 1 ?

?- atom_codes(X, "1").

X = '1' ?

?- number_codes(X, "1").

X = 1 ?

Slide 23 — Meta-logical predicates

• var(X) succeeds iff X is a free variable
• nonvar(X) succeeds iff X is not a free variable
• compound(X) succeeds iff X is instantiated to a compound term
• ground(X) succeeds iff X is fully instantiated — contains no variables anywhere

?- var(X), X = f(a).

X = f(a) ?

?- X = f(a), var(X).

no

?- X = f(Y), compound(X).

X = f(Y) ?

?- X = f(Y), ground(X).

no

What are they for? Two things: to control goal order for efficiency, and to restore some flexibility to programs that use non-reversible built-ins. The plus2/3 of slide 15 could have been written with nonvar/1 instead of number/1 — though number/1 is better there, because it also checks that what arrived is actually a number.

Slides 24–25 — Choosing an implementation by calling mode

:- module(_,_).

len([],0).
len([_|T],N) :- len(T,TN), N is TN+1.

?- len([a,b,c], N).

N = 3 ?

?- len(L, 3).

L = [_,_,_] ?

What we can do, though, is pick a different implementation depending on the direction, for efficiency. That is what the meta-logical predicates make possible:

:- module(_,_).

mylength(Xs,N):-
    var(Xs),
    integer(N),
    create_list(N,Xs).
mylength(Xs,N):-
    nonvar(Xs),
    compute_length(Xs,N).

create_list(0,[]).
create_list(N,[_|Xs]):-
    N > 0,
    N1 is N - 1,
    create_list(N1,Xs).

compute_length(L,N) :-
    compute_length_(L,0,N).

compute_length_([],N,N).
compute_length_([_|T],A,N) :-
    NA is A+1,
    compute_length_(T,NA,N).

?- mylength([a,b,c], N).

N = 3 ?

?- mylength(L, 3).

L = [_,_,_] ?

Why bother? Because create_list/2 is tail recursive — the recursive call is last, so the local variables are dead by the time it is made, the stack frame can be discarded, and the whole thing runs as a loop in constant memory. len/2 in that direction is not: its is/2 sits after the recursive call, so computing a length of a million pushes a million frames before any of them can return.

The second direction gets the same treatment, with an accumulating parameter. compute_length_/3 carries a counter that starts at 0 and grows by one per cons cell; the third argument is passed untouched all the way down and receives the answer at the base case. The addition now happens before the recursive call, so this version is tail recursive too.

Slide 26 — Comparing non-ground terms

Identity tests just look:

• X == Y (identical)
• X \== Y (not identical)

?- f(X) == f(X).

yes

?- f(X) == f(Y).

no

?- X = Y, X == Y.

Y = X ?

Term ordering gives a total order over all terms — which is algorithmically very convenient, because unless two terms are identical, one of them is definitely the larger:

• X @> Y, X @>= Y, X @< Y, X @=< Y

?- f(a) @> f(b).

no

?- f(b) @> f(a).

yes

?- f(a,b) @> g(a).

yes

Slide 27 — Two applications of term comparison

:- module(_,_).

subterm(Term,Term).
subterm(Sub,Term):-
    nonvar(Term),
    functor(Term,_F,N),
    n_to_one(N, J),
    arg(J,Term,Arg),
    subterm(Sub,Arg).

subterm_ng(Sub,Term) :- % a) identical, rather than unifiable
    Sub == Term.
subterm_ng(Sub,Term) :-
    nonvar(Term),
    functor(Term,_F,N),
    n_to_one(N, J),
    arg(J,Term,Arg),
    subterm_ng(Sub,Arg).

n_to_one(N, N) :- N > 0.
n_to_one(N, X) :- N > 1, N1 is N-1, n_to_one(N1, X).

?- subterm(f(a), g(X,k)).

X = f(a) ?

?- subterm_ng(f(a), g(X,k)).

no

?- subterm_ng(f(a), g(h(f(a)),k)).

yes

:- module(_,_).

insert_ee([], Item, [Item]).
insert_ee([H|T], Item, [H|T])       :- H == Item.
insert_ee([H|T], Item, [Item, H|T]) :- H @> Item.
insert_ee([H|T], Item, [H|NewT])    :- H @< Item, insert_ee(T, Item, NewT).

% The same program written with unification and arithmetic comparison:

insert_unif([], Item, [Item]).
insert_unif([H|T], Item, [H|T])       :- H = Item.
insert_unif([H|T], Item, [Item, H|T]) :- H > Item.
insert_unif([H|T], Item, [H|NewT])    :- H < Item, insert_unif(T, Item, NewT).

?- insert_ee([a,b,e], c, L).

L = [a,b,c,e] ?

?- insert_unif([a,b,e], c, L).

{ERROR: arithmetic:>/2, arg 1 - expected an arithmetically evaluable
 expression, found /(a,0)}

?- insert_ee([a,b,e], X, L).

L = [X,a,b,e] ?

?- insert_unif([a,b,e], X, L).

L = [a,b,e],
X = a ?

Slides 28–29 — The I/O predicates

Stream control — where are we reading from and writing to:

Term I/O — and this is the powerful group:

Character I/O, for binary work:

And write/1 is the exact converse. Hand it a pointer into the middle of an arbitrarily complicated structure and it prints whatever is there, to any depth, with no navigation code on your part.

Stream-based versions of all of these also exist, and are closer to what other languages do: open(File,Mode,S) with Mode one of read, write or append, and close(S); then write(S,X), nl(S), read(S,X), put_code(S,N), get_code(S,N). Use these when you need several files open at once — each gets its own stream identifier.

?- tell(bar), write(a+b), write('.'), told.        % bar contains:  a+b.
?- tell(baz), write_canonical(a+b), write('.'), told.  % baz contains: +(a,b).

Slide 30 — An example, and a warning

:- module(_,_).

:- use_module(library(stream_utils)).

write_list_to_file(L,F) :-
    telling(OldOutput),             % grab the current output stream
    tell(F), write_list(L), told,   % write into F, close
    tell(OldOutput).                % restore the previous output stream

write_list([]).
write_list([X|Xs]):-
    write(X),
    write('.'),
    nl,
    write_list(Xs).

show_file(F) :-
    file_to_string(F,L),
    format("~s",[L]).

?- write_list_to_file([f(a), m, g(k)], foo), show_file(foo).

f(a).
m.
g(k).

yes

Reading the file back one term at a time:

?- see(foo), read(X), read(Y), read(Z), read(W), seen.

W = end_of_file,
X = f(a),
Y = m,
Z = g(k) ?

Slides 31–32 — The pruning operator

When executed, a cut prunes exactly two things:

• all clauses below the clause the cut appears in, and
• all alternative solutions to the goals to its left in that clause.

:- module(_,_).

s(1) :- write('\n Clause 1 of s/1 succeeded.').
s(2) :- write('\n Clause 2 of s/1 succeeded.').

l(a) :- write('\n Clause 1 of l/1 succeeded.').
l(b) :- write('\n Clause 2 of l/1 succeeded.').

r(8) :- write('\n Clause 1 of r/1 succeeded.').
r(9) :- write('\n Clause 2 of r/1 succeeded.').

m(e) :- write('\n m/1 succeeded.').

p(X,_Y) :-
    l(X),
    write('\n Reached end of clause 1 of p.').
p(X,_Y) :-
    r(X),
    !,    % Cut
    write('\n Executed cut (no more alternatives of r/1 or p/1)'),
    write('\n At end of clause 2 of p.').
p(X,_Y) :-
    write('\n Reached clause 3 of p.'),
    m(X).

Trace it by hand first. s(A) succeeds with A = 1. In p, the first clause tries l(X); suppose that eventually fails. The second clause calls r(X), which succeeds with X = 8, and then the cut is executed. At that moment:

• r(9) disappears — it is an alternative of a goal to the left of the cut;
• the third clause of p/2 disappears — it is below the clause containing the cut.

Slide 33 — White and green cuts

:- module(_,_).

white_max(X,Y,X) :- X > Y, !.
white_max(X,Y,Y) :- X =< Y.

:- module(_,_).

address(X,Add) :- home_address(X,Add), !.
address(X,Add) :- business_address(X,Add).

home_address(john,pfluggerville).

business_address(john,austin).
business_address(mary,boston).

member_normal(X,[X|_]).
member_normal(X,[_|T]) :- member_normal(X,T).

member_check(X,[X|_]) :- !.
member_check(X,[_|T]) :- member_check(X,T).

?- member_normal(1,[1,2,1,4]), write('found solution'), nl, fail.

found solution
found solution

no

?- member_check(1,[1,2,1,4]), write('found solution'), nl, fail.

found solution

no

Slide 34 — Red cuts

Here is the first red cut everyone writes:

:- module(_,_).

red_max(X,Y,X) :- X > Y, !.   % Red cut!
red_max(_X,Y,Y).              % the X =< Y test is *missing*

?- red_max(5,2,M).

M = 5 ?

?- red_max(5,2,2).

yes

Why does it happen? red_max(5,2,2) fails against the first head, because X cannot be both 5 and 2, so the cut is never executed. It then reaches the second clause, red_max(_X,Y,Y), which says nothing about the first argument and only requires the last two to be equal — and they are.

Slide 35 — Living with red cuts

:- module(_,_).

red_max_delay_output(X,Y,M) :- X > Y, !, M = X.
red_max_delay_output(_X,Y,Y).

if_then_else_max(X,Y,M) :- ( X > Y -> M = X ; M = Y ).

?- red_max_delay_output(5,2,2).

no

Tip two: use if-then-else, which is syntactic sugar over exactly this pattern:

?- if_then_else_max(5,2,2).

no

case(a,Y) :- !, Y = 1.
case(b,Y) :- !, Y = 2.
case(c,Y) :- !, Y = 3.

case(a,1).
case(b,2).
case(c,3).

Slide 36 — Red cuts: the leap year, four ways

:- module(_,_).

days_in_year(Y,366) :- leap_year(Y), !.
days_in_year(_Y,365).

leap_year(Y) :- number(Y), 0 is Y mod 4.

?- days_in_year(4,D).

D = 366 ?

?- days_in_year(4,365).

yes

?- days_in_year(a,D).

D = 365 ?

Read the two clauses as logic, which is the whole point of the notation. The first says: a leap year has 366 days — true, no problem. The second says: any year has 365 days. Not "any other year" — any. So leap years satisfy both, and so does a. The program says exactly that, and the system is merely agreeing with you.

:- module(_,_).

days_in_year_good(Y,D) :- leap_year(Y),  !, D = 366.
days_in_year_good(Y,D) :- standard_year(Y), D = 365.

leap_year(Y)     :- number(Y), 0 is Y mod 4.
standard_year(Y) :- number(Y), R is Y mod 4, R \= 0.

?- days_in_year_good(4,365).

no

?- days_in_year_good(a,D).

no

days_in_year_delay_output(Y,D) :- leap_year(Y), !, D = 366.
days_in_year_delay_output(_Y,365).

days_in_year_moded(Y,_D) :- var(Y), !,
     write('{ ERROR: the year must be bound. }\n'), abort.
days_in_year_moded(Y, D) :- leap_year(Y), !, D = 366.
days_in_year_moded(_Y,365).

:- use_package([assertions,modes,rtchecks]).

:- pred days_in_year_moded_assrt(+int,-int).

days_in_year_moded_assrt(Y,D) :- leap_year(Y), !, D = 366.
days_in_year_moded_assrt(_Y,365).

Requires in *calls*:
    nonvar(_1)
But instead:
    var(_1)

:- module(_,_).

split([],[],[]).
split([X|L],[X|L1],L2) :- X >= 0, !, split(L,L1,L2).
split([X|L],L1,[X|L2]) :- split(L,L1,L2).       % should test X < 0

?- split([1,-1,3], L1, L2).

L1 = [1,3],
L2 = [-1] ?

:- module(_,_).

k_1sol(j,k).
k_1sol(X,Y) :- k(X), !, z(Y).
k_1sol(l,m).

k(a).  k(b).
z(1).  z(2).

?- k_1sol(X,Y).

X = j, Y = k ? ;
X = a, Y = 1 ? ;
X = a, Y = 2 ? ;
no

Slide 37 — Meta-calls and implementing higher order

That one predicate is what makes meta-programming possible: interpreters, shells, negation (next section), and higher order.

:- module(_,_).

p(X) :- call(X).

q(a,1).
q(b,2).

apply(P,Args) :-
    G =.. [P|Args],
    call(G).

maptuples(_P,[]).
maptuples(P,[Tuple|RTuples]) :-
    apply(P,Tuple),
    maptuples(P,RTuples).

?- G = q(a,Y), p(G).

G = q(a,1),
Y = 1 ?

:- module(_,_).

:- use_module(library(lists)).

?- Y = p, P =.. [Y,a].

P = p(a),
Y = p ?

?- F = member, Args = [X,[1,2,3]], P =.. [F|Args].

Args = [X,[1,2,3]],
F = member,
P = member(X,[1,2,3]) ?

?- F = member, L = [X,[1,2,3]], P =.. [F,L].

F = member,
L = [X,[1,2,3]],
P = member([X,[1,2,3]]) ?

?- F = append, Args = [X,Y,Z], P =.. [F|Args], call(P).

Args = [[],Y,Y],
F = append,
P = append([],Y,Y),
X = [],
Z = Y ?

apply(F,Args) :- G =.. [F|Args], call(G).

?- P = q, apply(P,[a,Y]).

P = q,
Y = 1 ?

?- maptuples(q,[[a,X],[b,Y]]).

X = 1,
Y = 2 ?

Slide 38 — call/n and the higher-order library

:- module(_,_,[hiord]).

:- use_module(library(lists)).
:- use_module(library(hiordlib)).

q(a,1).
q(b,2).

plus2(X,Y,Z) :- number(X), number(Y), Z is X + Y.
plus2(X,Y,Z) :- number(X), number(Z), Y is Z - X.
plus2(X,Y,Z) :- number(Y), number(Z), X is Z - Y.

?- P = q, call(P,X,Y).

P = q,
X = a,
Y = 1 ?

?- P = q(a), call(P,Y).

P = q(a),
Y = 1 ?

?- P = append, call(P,[1,2],[3,4],Y).

P = append,
Y = [1,2,3,4] ?

?- P = append(X,Y), call(P,[1,2,3,4]).

P = append([],[1,2,3,4]),
X = [],
Y = [1,2,3,4] ?

?- maplist(plus2, [1,2,3], [4,5,6], R).

R = [5,7,9] ?

?- maplist(plus2, [1,2,3], L2, [5,7,9]).

L2 = [4,5,6] ?

?- maplist(append, [ [a],   X,     X ],
                   [ [c,d], [e,f], Y ],
                   [ X,     Y,     Z] ).

X = [a,c,d],
Y = [a,c,d,e,f],
Z = [a,c,d,a,c,d,e,f] ?

Slide 39 — Ciao's hiord package

:- module(_,_,[hiord]).

:- use_module(library(lists)).
:- use_module(library(hiordlib)).

p(a,1).
p(b,2).

?- P = p, P(X,Y).

P = p,
X = a,
Y = 1 ?

?- P = append, P([1,2],[3,4],Y).

P = append,
Y = [1,2,3,4] ?

?- P = { _(X,Y) :- Y is X+1 }, P(3,R).

P = {''(X,Y):-Y is X+1},
R = 4 ?

?- maplist({ _(X,Y) :- Y is X+1 }, [1,2,3], R).

R = [2,3,4] ?

Slides 40–42 — Aggregation predicates

findall(Term, Goal, ListResults): ListResults is the list of all instances of Term for which Goal succeeds. If there are none, it is []. For it to terminate, the number of solutions must of course be finite and enumerable in finite time.

:- module(_,_).

likes(bill, cider).
likes(dick, beer).
likes(tom, beer).
likes(tom, cider).
likes(harry, beer).
likes(jan, cider).

?- findall(X, likes(X,Y), S).

S = [bill,dick,tom,tom,harry,jan] ?

The first argument is a pattern, and it does more than name a variable. It says what to build out of each solution:

?- findall(l(X), likes(X,Y), S).

S = [l(bill),l(dick),l(tom),l(tom),l(harry),l(jan)] ?

And an empty result is an empty list, not a failure:

?- findall(X, likes(X,water), S).

S = [] ?

?- setof(X, likes(X,Y), S).

S = [dick,harry,tom],
Y = beer ? ;
S = [bill,jan,tom],
Y = cider ? ;
no

?- findall(t(Y,S), setof(X,likes(X,Y),S), Pairs).

Pairs = [t(beer,[dick,harry,tom]),t(cider,[bill,jan,tom])] ?

?- setof(X, Y^likes(X,Y), S).

S = [bill,dick,harry,jan,tom] ?

?- setof(X, likes(X,water), S).

no

:- module(_,_).

subset([],[]).
subset([X|Xs],[X|Ys]) :- subset(Xs,Ys).
subset([_|Xs],Ys)     :- subset(Xs,Ys).

powerset(Set,Pset) :- setof(X,subset(Set,X),Pset).

?- powerset([1,2,3],Pset).

Pset = [[],[1],[1,2],[1,2,3],[1,3],[2],[2,3],[3]] ?

Slides 43–44 — Negation as failure

:- module(_,_).

not( Goal) :- call(Goal), !, fail.
not(_Goal).

unmarried_student(X) :-
    \+ married(X),
    student(X).

student(joe).
married(john).

The standard spelling is the prefix operator \+/1, so you write \+ member(c,[a,k,l]).

?- X = 1, \+ X = 2.

X = 1 ?

?- \+ X = 1.

no

:- module(_,_).

:- use_module(library(lists)).

?- L = [X,2,3], append([1],R,L).

L = [1,2,3],
R = [2,3],
X = 1 ?

?- L = [X,2,3], \+ \+ append([1],R,L).

L = [X,2,3] ?

Termination. \+ Goal terminates exactly when the search for Goal reaches a success node before an infinite branch. If Goal loops, so does its negation.

?- unmarried_student(joe).

yes

?- unmarried_student(X).

no

Asked about specific people it behaves perfectly: unmarried_student(joe) is yes, and unmarried_student(john) is no — for two independent reasons, since John is married and is not a student in this database. It is only generation that breaks.

Negation as failure is only correct for ground goals, and it is the programmer's responsibility to ensure that. The most frequent fix is simply to put the generator first, so the variable is bound by the time the negation runs:

unmarried_student(X) :- student(X), \+ married(X).

not_(G) :-
    ground(G), !,
    \+ G.
not_(G) :-
    write('ERROR: Non-ground goal in negation: '), write(G), nl,
    abort.

:- use_package([assertions,modes,rtchecks]).

:- pred not__(G) : ground(G).
not__(G) :- \+ G.

once(G) :- call(G), !.

Slide 45 — Cut-fail

The example is ground/1 itself — a term is ground if it contains no variables, so we fail as soon as we find one:

:- module(_,_).

ground_(Term):- var(Term), !, fail.
ground_(Term):-
    nonvar(Term),
    functor(Term,_F,N),
    ground_args(N,Term).

ground_args(0,_T).        %% all subterms traversed
ground_args(N,T):-
    N>0,
    arg(N,T,Arg),
    ground_(Arg),
    N1 is N-1,
    ground_args(N1,T).

?- ground_(f(a,g(b))).

yes

?- ground_(f(a,g(X))).

no

Useful, and dangerous for the same reason all cuts are: the failure is committed, so there is no backtracking into an alternative reading.

Slide 46 — Modifying the program at run time

There are cases where assertion and retraction can be logically justified:

• asserting clauses that logically follow from the program — lemmas;
• retracting clauses that are logically redundant.

Requirements differ between implementations. Typically a predicate that does not already appear in the program can always be asserted; otherwise it must be declared :- dynamic.

Slide 47 — Assert and retract in action

:- module(_,_).

related(3,4).
:- dynamic related/2.

relate_numbers(X,Y)   :- assert(related(X,Y)).
unrelate_numbers(X,Y) :- retract(related(X,Y)).

?- related(1,2).

no

?- relate_numbers(1,2), related(1,2).

yes

?- relate_numbers(1,2), unrelate_numbers(1,2), related(1,2).

no

Rules can be asserted too, not just facts. Since a clause is a term, you build the term and assert it:

:- module(_,_).

:- dynamic app/3.

define_app :-
    assert(   app([], X, X) ),
    assert( ( app([X|Y], Z, [X|W]) :- app(Y,Z,W) ) ).

erase_app :-
    abolish(app/3).

?- define_app, app([1,2],[3,4],Y).

Y = [1,2,3,4] ?

?- C = (related(X,Y) :- X =< Y), assert(C).

C = (related(X,Y):-X=<Y) ?

?- related(1,2).     yes
?- related(2,1).     no

Slide 48 — Lemmas: the one clearly good use

:- module(_,_).

% 1) Direct definition:

fib(0, 0).
fib(1, 1).
fib(N, F) :-
    N > 1,
    N1 is N - 1,
    N2 is N - 2,
    fib(N1, F1),
    fib(N2, F2),
    F is F1 + F2.

% 2) Version that records 'lemmas' (things already proved):

:- dynamic lemma_fib/2.
lemma_fib(0, 0).
lemma_fib(1, 1).

lfib(N, F) :-
    lemma_fib(N, F),          % already known? take it
    !.
lfib(N, F) :-
    N > 1,
    N1 is N - 1,
    N2 is N - 2,
    lfib(N1, F1),
    lfib(N2, F2),
    F is F1 + F2,
    assert(lemma_fib(N, F)).  % ...and remember it

Print a line on every call and ask for position 4 and you see it: the calls are 3, 2, 1, 0, 1, 2, 1, 0 — position 3 computed once, position 2 twice, position 1 three times. Exponential: each new number recomputes the whole tree beneath it.

The lemma version differs in exactly two places — look it up if we already have it, and record what we just computed. The first time you call it, it makes about the same number of calls, in fact slightly fewer, because as soon as it reaches a position it has already computed it stops descending. And the second call is where it pays: asking for position 5 after position 4 needs only one addition, because 4 and 3 are both already known.

What that buys, measured in this Ciao on the machine these notes were written on:

?- statistics(walltime,_), fib(27,Y), statistics(walltime,[_,T]).

T = 36.843,
Y = 196418 ?

?- statistics(walltime,_), lfib(27,Y), statistics(walltime,[_,T]).

T = 0.028,
Y = 196418 ?

?- lfib(200,Y).

Y = 280571172992510140037611932413038677189525 ?

Slide 49 — Meta-interpreters

You cannot call it with the head completely unbound — that would be asking to enumerate every clause in the program — so you give it a head pattern and it enumerates the matching clauses on backtracking. For lappend/3 it returns the two you would expect:

cl(lappend([],A,A), true)
cl(lappend([B|C],A,[B|D]), lappend(C,A,D))

With it you can write an interpreter for Prolog, in Prolog, in three lines:

:- module(_,_,[]).

:- use_package(dynamic_clauses).

:- dynamic lappend/3.

lappend([],X,X).
lappend([X|Y],Z,[X|W]) :- lappend(Y,Z,W).

% The 'vanilla' meta-interpreter:
solve( true  ) :- !.
solve( (A,B) ) :- !, solve(A), solve(B).
solve( A     ) :- clause(A,B), solve(B).

?- solve(lappend([1,2],[3,4],L)).

L = [1,2,3,4] ?

?- solve(lappend(X,Y,[1,2,3,4])).

X = [],
Y = [1,2,3,4] ? ;
X = [1],
Y = [2,3,4] ? ;
X = [1,2],
Y = [3,4] ? ;
X = [1,2,3],
Y = [4] ? ;
X = [1,2,3,4],
Y = [] ? ;
no

Slide 50 — Extending the meta-interpreter

Tracing is the easiest. Put a write/1 and nl/0 in the third clause and every goal the interpreter attempts is printed — without modifying the program being interpreted at all. Put them after the recursive call instead and you see the state on the way back out, which is how the answer list gets built. That is already a usable debugger, in two extra goals.

Add one argument instead and you have a step counter:

:- module(_,_,[]).

:- use_package(dynamic_clauses).

:- dynamic lappend/3.

lappend([],X,X).
lappend([X|Y],Z,[X|W]) :- lappend(Y,Z,W).

csolve( true,  0) :- !.
csolve( (A,B), N) :- !, csolve(A,NA), csolve(B,NB), N is NA+NB.
csolve( A,     N) :- clause(A,B), csolve(B,N1), N is N1+1.

?- csolve(lappend([1,2],[3,4],L),N).

L = [1,2,3,4],
N = 3 ?

?- csolve(lappend([1,2,a,b],[3,4],L),N).

L = [1,2,a,b,3,4],
N = 5 ?

?- csolve(lappend([1,2],[3,4,a,b],L),N).

L = [1,2,3,4,a,b],
N = 3 ?

Trace the three steps against the program and they line up exactly: one for each element of [1,2], and one more where the base case lappend([],X,X) matches. This is a genuinely useful way to find the complexity of a predicate: you get a number rather than an argument.

Slide 51 — Difference lists

Start with why ordinary append/3 is expensive. You have a pointer X to [1,2,3], ending in [], and a pointer Y to [4,5]. append(X,Y,Z) builds the result by taking the head off the first list and putting it at the front of the result, over and over — that is, it copies the first list. Only when it reaches the base case, append([],L,L), does it make the last cell point at Y. So the second list is not copied; the first one is, entirely. That is where the cost comes from.

What you would rather do is attach something at the end of the first list. And you can — if you leave the tail as a free variable and keep a pointer to it. Then appending is a single unification: point the tail at the second list. Constant time.

[1,2,3] is a closed list: it ends in [], and you cannot add to the end without walking to it first — which is exactly why append/3 costs the length of its first argument.

An incomplete (or open) list ends in a variable: [1,2,3|T]. Now you can add at the end, by instantiating T. The idea of a difference list is to carry that variable around with the list, so you always have a pointer to the end:

:- module(_,_).

% A pseudo-type for difference lists:
dlist(X-X).
dlist([_|DL]-X) :- dlist(DL-X).

% Appending difference lists, in constant time:
append_dl(B1-E1, E1-E2, B1-E2).

dlist(X-Y)      :- var(X), !, X == Y.
dlist([_|DL]-X) :- dlist(DL-X).

The explicit version of the append reads more clearly:

append_dl(B1-E1,B2-E2,B3-E3) :- B3=B1, E3=E2, B2=E1.

Slide 52 — Playing with difference lists

?- L1 = [1,2,3|X], L2 = [4,5|Y], L2 = X.

L1 = [1,2,3,4,5|Y],
L2 = [4,5|Y],
X = [4,5|Y] ?

Now through the predicate:

?- append_dl([1,2,3|X]-X, [4,5|Y]-Y, L).

L = [1,2,3,4,5|Y]-Y,
X = [4,5|Y] ?

And it runs backwards, because it is a fact and everything is unification. Given the result and the second list, it recovers the first:

?- append_dl(L-X, [4,5|Y]-Y, [1,2,3,4,5|Z]-Z).

L = [1,2,3,4,5|Y],
X = [4,5|Y],
Z = Y ?

Slides 53–54 — Quicksort with ordinary lists

:- module(_,_).

:- use_module(library(lists)).

qsort([],[]).
qsort([X|L],S) :-           % take the first element of the list in X
   partition(L,X,LS,LB),    % LS: elements of L < X;  LB: elements >= X
   qsort(LS,LSS),           % LSS is LS sorted
   qsort(LB,LBS),           % LBS is LB sorted
   append(LSS,[X|LBS],S).   % put the pivot between the two sorted halves

partition([],_P,[],[]).
partition([E|R],P,[E|Smalls],Bigs) :-
    E < P,
    partition(R,P,Smalls,Bigs).
partition([E|R],P,Smalls,[E|Bigs]) :-
    E >= P,
    partition(R,P,Smalls,Bigs).

?- qsort([5,2,1,3,7,6], SL).

SL = [1,2,3,5,6,7] ?

That append/3 is the waste. It walks the whole left half again, at every level of the recursion.

Slides 55–57 — Quicksort with difference lists, in three steps

:- module(_,_).

qsort_dl1(L,SL) :-          % L  = [5,2,1,3,7,6]
    qsort_dl1_(L,SL-SLE),   % SL = [1,2,3,5,6,7|SLE]
    SLE = [].               % SL = [1,2,3,5,6,7]

qsort_dl1_([],SLE-SLE).
qsort_dl1_([X|L],SL-SLE) :- % X = 5, L = [2,1,3,7,6]
    partition(L,X,S,B),     % S = [2,1,3], B = [7,6]
    qsort_dl1_(S,SS-SSE),   % SS  = [1,2,3|SSE]
    qsort_dl1_(B,BS-BSE),   % BS  = [6,7|BSE]
    SSE = [X|BS],           % SSE = [5,6,7|BSE]
    SL = SS,                % SL  = [1,2,3,5,6,7|BSE]
    SLE = BSE.              % SL  = [1,2,3,5,6,7|SLE]

partition([],_P,[],[]).
partition([E|R],P,[E|Smalls],Bigs) :- E <  P, partition(R,P,Smalls,Bigs).
partition([E|R],P,Smalls,[E|Bigs]) :- E >= P, partition(R,P,Smalls,Bigs).

?- qsort_dl1([5,2,1,3,7,6], SL).

SL = [1,2,3,5,6,7] ?

Now comes the point where the old version did the append/3 — and here is the magic. What came back are difference lists, so we have a handle on the end of each. Three unifications suffice:

• SL = SS — the result starts where the small ones start.
• SLE = BSE — the result ends where the big ones end.
• SSE = [X|BS] — and the hole at the end of the small ones gets the pivot followed by the big ones.

No traversal, no append/3. And the top-level qsort_dl1/2 then does one last thing for the benefit of a caller who knows nothing about difference lists: SLE = [] closes the open tail, converting the difference list back into an ordinary one.

Version 2 — the same program, with the unifications moved into the head and the arguments, where they belong:

:- module(_,_).

qsort_dl2(L,SL) :-
    qsort_dl2_(L,SL-[]).

qsort_dl2_([],SLE-SLE).
qsort_dl2_([X|L],SL-SLE) :-
    partition(L,X,S,B),
    qsort_dl2_(S,SL-[X|BS]),
    qsort_dl2_(B,BS-SLE).

partition([],_P,[],[]).
partition([E|R],P,[E|Smalls],Bigs) :- E <  P, partition(R,P,Smalls,Bigs).
partition([E|R],P,Smalls,[E|Bigs]) :- E >= P, partition(R,P,Smalls,Bigs).

?- qsort_dl2([5,2,1,3,7,6], SL).

SL = [1,2,3,5,6,7] ?

Version 3 — drop the -/2 functor and use two arguments instead:

:- module(_,_).

qsort_dl(L,SL) :-
    qsort_dl_(L,SL,[]).

qsort_dl_([],SLE,SLE).
qsort_dl_([X|L],SL,SLE) :-
    partition(L,X,S,B),
    qsort_dl_(S,SL,[X|BS]),
    qsort_dl_(B,BS,SLE).

partition([],_P,[],[]).
partition([E|R],P,[E|Smalls],Bigs) :- E <  P, partition(R,P,Smalls,Bigs).
partition([E|R],P,Smalls,[E|Bigs]) :- E >= P, partition(R,P,Smalls,Bigs).

?- qsort_dl([5,2,1,3,7,6], SL).

SL = [1,2,3,5,6,7] ?

Remember this shape — a pair of arguments, one for the list and one for its tail — because it is exactly what the grammar section is about.

Slide 58 — Parsing with append and ordinary lists

:- module(_,_).

:- use_module(library(lists)).

myphrase(P) :-
    append(A,T1,P),   article(A),
    append(S1,T2,T1), spaces(S1),  % spaces must follow
    append(N,T3,T2),  noun(N),     % a noun must follow
    append(S2,V,T3),  spaces(S2),  % spaces must follow
                      verb(V).     % must end with a verb

article([a]).
article([t,h,e]).

spaces([' ']).
spaces([' ' | Y]) :- spaces(Y).

noun([c,a,r]).
noun([p,l,a,n,e]).

verb([f,l,i,e,s]).
verb([d,r,i,v,e,s]).

?- myphrase([t,h,e,' ',p,l,a,n,e,' ',f,l,i,e,s]).

yes

How does it work? article(A) picks an article — a or the — and then append(A,T1,P), run backwards, asks whether the phrase starts with it, handing back the rest as T1. Then the same question is asked of T1, and so on down the phrase. append/3 is being used to subtract a piece off the front.

?- myphrase([' ',t,h,e,' ',p,l,a,n,e,' ',f,l,i,e,s]).

no

?- myphrase([a,' ',' ',p,l,a,n,e,' ',d,r,i,v,e,s]).

yes

It works, and it is generate and test: append/3 proposes every possible split of the list, and article/1 and the rest reject the bad ones. Every split of every remaining tail — the cost is appalling, and there are four append/3 calls.

Slide 59 — The same, with difference lists

:- module(_,_).

myphrase(P,C) :-
    article(P,CA), spaces(CA,CS1),
    noun(CS1,CN),  spaces(CN,CS2),
    verb(CS2,C).

article([a       | T],T).
article([t,h,e   | T],T).

spaces([' ' | T],T).
spaces([' ' | Y],T) :- spaces(Y,T).

noun([c,a,r     | T],T).
noun([p,l,a,n,e | T],T).

verb([f,l,i,e,s  | T],T).
verb([d,r,i,v,e,s| T],T).

?- myphrase([t,h,e,' ',p,l,a,n,e,' ',f,l,i,e,s],[]).

yes

This is the difference-list pair from the quicksort section, doing a completely different job. The chaining of the variables — P to CA to CS1 to CN to CS2 to C — is the sequencing of the grammar.

Slide 60 — The same again, with string syntax

:- module(_,_).

myphrase(X,C) :-
    article(X,CA), spaces(CA,CS1),
    noun(CS1,CN),  spaces(CN,CS2),
    verb(CS2,C).

article("a"     || T, T).
article("the"   || T, T).

spaces(" " || T, T).
spaces(" " || Y, T) :- spaces(Y, T).

noun("car"      || T, T).
noun("plane"    || T, T).

verb("flies"    || T, T).
verb("drives"   || T, T).

?- myphrase("the plane flies",[]).

yes

?- myphrase("the plane drove",[]).

no

Slides 61–62 — Definite clause grammars

So let the system add them. That transformation is what a definite clause grammar is: --> is a macro that expands into the threaded two-argument version.

:- module(_,_).

:- use_package(dcg).

myphrase --> article, spaces, noun, spaces, verb.

article --> "a".
article --> "the".

spaces  --> " ".
spaces  --> " ", spaces.

noun    --> "car".
noun    --> "plane".

verb    --> "flies".
verb    --> "drives".

myphrase(X,CV) :- article(X,CA), spaces(CA,CS1), noun(CS1,CN),
                  spaces(CN,CS2), verb(CS2,CV).

?- myphrase("the plane flies",[]).

yes

You can also use the phrase/2 built-in, which supplies the [] for you:

?- phrase(myphrase,"the plane flies").

yes

?- myphrase(S,[]).

S = "a car flies" ?

Slide 63 — Parsing with actions

Grammar rules can carry extra arguments, and can call ordinary Prolog between braces { ... } — anything in braces is straight Prolog and does not get the hidden arguments added. And note where the extra arguments go: the two hidden ones are always the last two, so yours go in front of them.

Here is the same grammar, counting the characters it consumes:

:- module(_,_).

:- use_package(dcg).

myphrase(N) --> article(AC), spaces(S1), noun(NC), spaces(S2),
                verb(VC), { N is AC + S1 + NC + S2 + VC }.

article(1) --> "a".
article(3) --> "the".

spaces(1)  --> " ".
spaces(N)  --> " ", spaces(N1), { N is N1+1 }.

noun(3)    --> "car".
noun(5)    --> "plane".

verb(5)    --> "flies".
verb(6)    --> "drives".

?- myphrase(N,"the plane flies",[]).

N = 15 ?

?- phrase(myphrase(N),"the plane flies").

N = 15 ?

Read the rules. article(1) --> "a". says an article may be a, and it has one character. The spaces rule is the pretty one: one space has one character; and a space followed by more spaces, which have N1 characters, has N1 + 1 — with { N is N1+1 } being plain Prolog dropped into the middle of a grammar rule. So spaces//1 really has three arguments: the two hidden ones doing the difference-list threading, and the extra one carrying the count.

The counts travel in that extra argument, and a final { ... } adds them up. Which is exactly how you would build an abstract syntax tree as you parse, or compute a value, or check a context condition — the grammar and the semantic actions live in the same notation.

Slide 64 — Other issues in Prolog

Repeat loops and failure-driven loops. The pattern is worth recognizing, because it is what imperative Prolog looks like:

main(_) :- repeat, read(X), process(X).

process(end).
process(X) :- display(X), nl, fail.

Also: exception handling; extending the syntax beyond operators with term expansions and macros, which is what a package is; delay declarations and concurrency; the operating system interface, sockets; foreign language interfaces such as C; and a great many more built-ins.

Slide 65 — Libraries

Slides 66–68 — Extensions, taking Ciao as the example

Other execution rules. Breadth-first, iterative deepening, random; tabling; CASP (negation with multiple models); Andorra ("determinate-first") execution; fuzzy Prolog. You have used one of these all along — sr/bfall — so the mechanism is already familiar.

Interfaces to other languages and systems. C, Java, JavaScript, Python, LLVM; an SQL database interface and persistent predicates; web, HTML, XML and CGI programming (PiLLoW), HTTP connectivity, JSON, compilation to JavaScript; interfaces to solvers (PPL, Mathematica, MiniSAT, Z3, Yices); Graphviz and daVinci; Electron, wxWidgets, Tcl/Tk, VRML.

Syntactic and semantic extensions. Functional notation and higher order — both of which appeared in these notes; terms with named arguments (records and feature terms); multiple argument indexing; the script interpreter; active modules for high-level distributed execution; concurrency and multithreading; attributed variables; object-oriented programming.

Constraint programming. Rationals, reals, finite domains; CHR (constraint handling rules), GeCode. This is the subject of the last part of the course, and it is where the arithmetic we lost on slide 13 comes back — declarative and efficient.

Assertions, which appeared here twice as a way of stating what a predicate expects: regular types, modes, determinacy and other properties; run-time checking; assertion-based unit tests and automatic test case generation; and compile-time property inference and assertion checking with CiaoPP.

Additional programming support. Automatic documentation (LPdoc — which produced the document you are reading); partial evaluation, optimization and parallelization (CiaoPP).