Calling the Interpreter

call

Functions may be used as queries by putting them as arguments to call. (CallGoal)

execute(Functor,ArgumentList):-
    Goal =.. [Functor|ArgumentList],
    call(Goal).

Most Prologs allow the term to be placed directly as a goal, without using call. (DirectGoal)
```
execute(Functor,ArgumentList):-
    Goal =.. [Functor|ArgumentList],
    Goal.
 
```

Example: To apply a function to every member of a list and return a list of results. (ApplyGoal)

apply(_,[],[]).

apply(Functor,[Head|Tail],[HeadResult|TailResult]):-
    Function =.. [Functor,Head,HeadResult],
    Function,
    apply(Functor,Tail,TailResult).

Example - Using call, fail and cut to implement not. (NotGoal)
```
my_not(Goal):-
    Goal,
    !,
    fail.

my_not(Goal).
 
```

Dynamic Predicates

asserta, assertz, retract

These add and remove clauses from the program.
asserta(X) adds the clause X to the program before any other clauses with the same head predicate symbol. X must be instantiated so that the head predicate symbol is known.
assertz(X) adds X to the program after any clauses with the same head predicate symbol. This is simply assert in some (including Eclipse) Prologs.
assert is not undone on backtracking. retract must be used to remove something from the program.
retract(X) removes, from the program, a clause that unifies with X. X must be instantiated so that the head predicate symbol and arity are known.
Like assert, retract is not undone on backtracking.
retract_all(X) is available in Eclipse to remove all clauses that unify with X.
retractall(X) is available in SWI to remove all clauses that unify with X.
Eclipse and SWI require that predicates that will be asserted and retracted be declared as dynamic if they are going to be first encountered in a compilation context.

Example : Use for storing data (LibraryDB)

borrow(Book,Date):-
    retract(shelf(Book)),
    assertz(loan(Book,Date)).

return(Book,Date,Fine):-
    retract(loan(Book,BorrowDate)),
    asserta(shelf(Book)),
    calculate_fine(BorrowDate,Date,Fine).

calculate_fine(BorrowDate,ReturnDate,25):-
    Days is ReturnDate - BorrowDate,
    Days > 14,
    !.

calculate_fine(_,_,0).

:- dynamic shelf/1.
shelf(bible).
shelf(koran).
shelf(ekat).

Example : Multiplication table (MultiplyDB)

make_table(RowNumbers,ColumnNumbers):-
    member(Row,RowNumbers),
    member(Column,ColumnNumbers),
    Product is Row*Column,
    assertz(product(Row,Column,Product)),
    fail.

-----------------------------------------------------------
?- make_table([1,2,3],[4,5,6]).
no.

?- product(2,4,X).
yes
X = 8

Example : Random numbers (RandomDB)

:-dynamic seed/1.

%----The intial seed
seed(1111).

%----The random number generator
random(Lowest,Highest,Random):-
    retract(seed(Seed)),
    Random is Lowest + (Seed mod (Highest-Lowest+1)),
    New_seed is (125 * Seed + 1) mod 4096,
    asserta(seed(New_seed)).

Example : Generating new atoms (NewAtomsDB)

%----This root encountered before
get_root_number(Root,Number):-
    retract(current_number(Root,N1)),
    !,
    Number is N1 + 1,
    asserta(current_number(Root,Number)).

%----First time for this root
get_root_number(Root,1):-
    asserta(current_number(Root,1)).

generate_symbol(Root,Atom):-
    get_root_number(Root,Number),
    name(Root,Name1),
    name(Number,Name2),
    append(Name1,Name2,Name),
    name(Atom,Name).

Example : Making a copy of an expression with new variables. (CopyTermDB)

copy(Original,Copy):-
    assertz(save(Original)),
    retract(save(Copy)).

Example : Memoizing to improve the efficiency of generating Fibonacci numbers (FactorialDB)

:-dynamic fibonacci/2.

fibonacci(1,1).

fibonacci(2,1).

fibonacci(Number,Fibonnaci):-
    Number > 2,
    N1 is Number - 1,
    fibonacci(N1,F1),
    N2 is Number - 2,
    fibonacci(N2,F2),
    Fibonacci is F1 + F2,
    asserta((fibonacci(Number,Fibonacci):-!)).

Prolog is used by relational database developers, using these predicates to store and remove data. The relation name is used as the predicate symbol, and each field of a tuple is stored as an argument of a fact. The relational select operation is immediately available, with unifiability as the selection criteria, via a query. By allowing rules in the relational database a deductive database is formed. These predicates should never be used to store temporary results - use another variable.

clause(Head,Tail)

Satisfying a goal of the form clause(Head,Tail) unifies Head and Tail with the head and tail of a dynamic clause in the program.
The tail comes back in the form of a term if a single tail predicate, or as a right associative conjunction otherwise.
Head must be instantiated enough so that the head predicate symbol and arity are known.
If the clause is a fact, Tail is true.

Example (Listing)

listing(Predicate,Arity):-
    functor(Head,Predicate,Arity),
    clause(Head,Tail),
    write(Head),
    write(':-'),
    write(Tail),
    fail.

Example - Meta-interpreter (Interpreter)

run(true):-
    !.

run((FirstQuery,RestOfQueries)):-
    !,
    run(FirstQuery),
    run(RestOfQueries).

run(Query):-
    clause(Query,Tail),
    run(Tail).

Example : Changing the program at run time
- This in some ways seems to be a form of "intelligence", if a program can modify and improve itself. Rules may be induced from large data samples and asserted as general.
- Example : The intelligent program may search the database and find that every object that has property a (i.e. a(<object>). is in the program) also has property b. The intelligent program may then assert b(X):-a(X), and remove all the specific facts.
- Suicidal and replicating clauses.

Collectors

These are used for collecting up alternative solutions, as would be provided by asking for more at the prompt.

findall(Variable,Query,ListOfSolutionsForTheVariable)

For each possible solution of Query, the values of Variable are collected together into the List, in the order in which they are found.

Example : findall (QUnifyBack4)

lecturer(olivier,ai).
lecturer(john,pascal).
lecturer(olivier,ai).
lecturer(geoff,ai).
lecturer(john,programming).
lecturer(nizam,networks).
lecturer(peter,graphics).
lecturer(geoff,projects).
lecturer(olivier,ppl).
lecturer(john,graphics).

--------------------------------------------------------
?- findall(Subject,lecturer(Person,Subject),SubjectList).
yes
SubjectList = [ai,pascal,ai,ai,programming,networks,graphics,projects,ppl,graphics]

bagof(Variable,Query,ListOfSolutionsForTheVariable)

For each combination of solutions for variables other than Variable in the Query, all possible solutions for the Variable are collected together into the List, in the order in which they are found.
bagof has itself multiple solutions.

Example : bagof (QUnifyBack4)

lecturer(olivier,ai).
lecturer(john,pascal).
lecturer(olivier,ai).
lecturer(geoff,ai).
lecturer(john,programming).
lecturer(nizam,networks).
lecturer(peter,graphics).
lecturer(geoff,projects).
lecturer(olivier,ppl).
lecturer(john,graphics).

--------------------------------------------------------
?- bagof(Subject,lecturer(Person,Subject),SubjectList).
yes
Person = olivier
SubjectList = [ai,ai,ppl]    ? ;
yes
Person = john 
SubjectList = [pascal,programming,graphics]    ? ;
yes
Person = geoff
SubjectList = [ai,projects] ? etc, etc

setof(Variable,Query,ListOfSolutionsForTheVariable)

As for bagof, but the list has duplicates removed and is ordered lexicographically.

Example : setof (QUnifyBack4)

lecturer(olivier,ai).
lecturer(john,pascal).
lecturer(olivier,ai).
lecturer(geoff,ai).
lecturer(john,programming).
lecturer(nizam,networks).
lecturer(peter,graphics).
lecturer(geoff,projects).
lecturer(olivier,ppl).
lecturer(john,graphics).

--------------------------------------------------------
?- setof(Subject,lecturer(Person,Subject),SubjectList).
yes
Person = olivier
SubjectList = [ai,ppl]    ? ;
yes
Person = john 
SubjectList = [graphics,pascal,programming]    ? ;
yes
Person = geoff
SubjectList = [ai,projects] ? etc, etc

Tutorial

Write your own version of consult and reconsult.

Here's a dirty implementation of findall that does not work for nested findalls.

findall(Variable,Goal,_):-
    Goal, 
    assertz(found(Variable)),
    fail.

findall(_,_,List):-
    collect_found(List).
    
collect_found([FirstFound|RestFound]):-
    retract(found(FirstFound)),
    !,
    collect_found(RestFound).

collect_found([]).

Write a version of findall that works for nested invocations.