Prolog

Lists
 Lists
 [ ] is the empty list.
 [x, 2+2, [a, b, c]] is a list of three elements.
 The first element in the list is its head.
 The list with the head removed is the tail.
 The head of [x, 2+2, [a, b, c]] is x
 The tail is [2+2, [a, b, c]]

2
 Lists
 Unification can be performed on lists:
 [a, b, c] = [X, Y, Z]
results in X = a, Y = b, Z = c
 [a, b, c] = [Head | Tail]
results in Head = a, Tail = [b, c]
 Nonempty lists can be matched against
[Head|Tail].
 Empty lists will not match [Head|Tail].

3
 Matching Heads and Tails
 If [a, b, c] = [Head | Tail], then
a = Head and [b, c] = Tail
 If [a, b, c] = [X, Y | Tail], then
a = X, b = Y, and [c] = Tail
 If [a, b, c] = [X, Y, Z | Tail], then
a = X, b = Y, c = Z, and [ ] = Tail
 The tail of a list is always itself a list.
 [X | Y, Z] isn’t legal.

4
 Making Use of Unification
 Prolog has no functions. But you can use a
parameter as an “output variable.”
 first([Head | Tail], X) :- X = Head.
 Better: first([Head | Tail], Head).
 You can use unification in parameter lists to do
much of the needed work
 first([X | _ ], X).
 second([ _, X | _ ], X).
 third([ _, _, X | _ ], X).

5
 Structures and Lists
 The “univ” operator, =.. , can be used to convert
between structures and lists:
 loves(chuck, X) =.. [loves, chuck, X]

 Double quotes indicate a list of ASCII values:

6
 Recursion
 Recursion is fully supported
 element(1, [X | _ ], X).
 element(N, [ _ | X], Y) :-
M is N - 1,
element(M, X, Y).
 This is the typical way to process lists: do something
with the head, recur with the tail.

7
 member
 member(X, [X | _ ]).
 member(X, [ _ | Y]) :- member(X, Y).
 As usual, base cases go first, then recursive cases.
 There is in general no need for a “fail” case, because
the predicate automatically fails if no clause is
matched.
 member(_, [ ]) :- fail.

8
 Accumulated Information
 If you reach a clause, you can assume that the earlier
clauses of the same predicate have failed.
 member(X, [X | _ ]).
 If you fail this clause, the first element is not the one
you want, so
member(X, [ _ | Y] :- member(X, Y).

9
 Backtracking and Beads
 Each Prolog call is like a “bead” in a string of beads:
call exit
fail redo

loves(chuck, X) :- female(X), rich(X).

10
 Fail Loops
 It is possible to build a “fail loop” in Prolog
 print_elements(List) :-
member(X, List), write(X), nl,
fail.

 But recursion is almost always better:

11
 Forcing a predicate to succeed

notice_objects_at(Place) :-
at(X, Place),
write('There is a '), write(X),
write(' here.'), nl,
fail.

notice_objects_at(_).

12
 Forcing a predicate to fail

loves(chuck, X) :-
really_ugly(X), !, fail.
loves(chuck, X) :-
female(X), rich(X).

13
 “Wrapping” another predicate
 The buzz_off/0 predicate might succeed or fail.
This is usually what we want.
 But sometimes we want to “ignore” failure (meaning,
force the predicate to succeed).

optional_buzz_off :-
buzz_off.

optional_buzz_off.

14
The End

15