CHAPTER 3    Visual Prolog Programs

Unlike other versions of Prolog, Visual Prolog is a typed Prolog compiler; you declare the types of the objects that each predicate applies to. The type declarations allow Visual Prolog programs to be compiled right down to native machine code, giving execution speeds similar to those of compiled C and pascal.

We discuss the four basic sections of a Visual Prolog program--where you declare and define the predicates and arguments, define rules, and specify the program's goal--in the first part of this chapter. In the second part of this chapter we take a closer look at declarations and rule syntax. Then, at the end of this chapter, we briefly introduce the other sections of a Visual Prolog program, including the facts, constants, and various global sections, and compiler directives.

The clauses section is the heart of a Visual Prolog program; this is where you put the facts and rules that Visual Prolog will operate on when trying to satisfy the program's goal.

The predicates section is where you declare your predicates and the domains (types) of the arguments to your predicates. (You don't need to declare Visual Prolog's built-in predicates.)

The domains section is where you declare any domains you're using that aren't Visual Prolog's standard domains. (You don't need to declare standard domains.)

The goal section is where you put the starting goal for a Visual Prolog program.

The clauses section is where you put all the facts and rules that make up your program. Most of the discussion in Chapter 2 was centered around the clauses (facts and rules) in your programs; what they convey, how to write them, and so on.

If you understand what facts and rules are and how to write them in Prolog, you know what goes in the clauses section. Clauses for a given predicate must be placed together in the clauses section; a sequence of clauses defining a predicate is called a procedure.

When attempting to satisfy a goal, Visual Prolog will start at the top of the clauses section, looking at each fact and rule as it searches for a match. As Visual Prolog proceeds down through the clauses section, it places internal pointers next to each clause that matches the current subgoal. If that clause is not part of a logical path that leads to a solution, Visual Prolog returns to the set pointer and looks for another match (this is backtracking, which we mentioned in Chapter 2).

2. The Predicates Section

If you define your own predicate in the clauses section of a Visual Prolog program, you must declare it in a predicates section, or Visual Prolog won't know what you're talking about. When you declare a predicate, you tell Visual Prolog which domains the arguments of that predicate belong to.

Visual Prolog comes with a wealth of built-in predicates. You don't need to declare any of Visual Prolog's built-in predicates that you use in your program. The Visual Prolog on-line help gives a full explanation of the built-in predicates.

Facts and rules define predicates. The predicates section of the program simply lists each predicate, showing the types (domains) of its arguments. Although the clauses section is the heart of your program, Visual Prolog gets much of its efficiency from the fact that you also declare the types of objects (arguments) that your facts and rules refer to.

How to Declare User-Defined Predicates

A predicate declaration begins with the predicate name, followed by an open (left) parenthesis. After the predicate name and the open parenthesis come zero or more arguments to the predicate.

    predicateName(argument_type1, argument_type2, ..., argument_typeN)

Each argument type is followed by a comma, and the last argument type is followed by the closing (right) parenthesis. Note that, unlike the clauses in the clauses section of your program, a predicate declaration is not followed by a period. The argument types are either standard domains or domains that you've declared in the domains section.

Predicate Names

The name of a predicate must begin with a letter, followed by a sequence of letters, digits, and underscores. The case of the letters does not matter, but we strongly recommend using only a lower-case letter as the first letter in the predicate name. (Other versions of Prolog don't allow predicate names to begin with upper-case letters or underscores, and future versions of Visual Prolog might not, either.) Predicate names can be up to 250 characters long.

You can't use spaces, the minus sign, asterisks, slashes, or other non-alphanumeric characters in predicate names. Valid naming charactersnaming characters in Visual Prolog consist of the following:

Upper-case Letters	:   A, B, ... , Z
Lower-case Letters	:   a, b, ... , z
Digits	:   0, 1, ... , 9
Underscore character	:   _

All predicate names and arguments can consist of combinations of these characters, as long as you obey the rules for forming both predicate and argument names.

Below are a few examples of legal and illegal predicate names.

Legal Predicate Names	Illegal Predicate Names
fact	[fact]
is_a	*is_a*
has_a	has/a
patternCheckList	pattern-Check-List
choose_Menu_Item	choose Menu Item
predicateName	predicate<Name>
first_in_10	>first_in_10

Predicate Arguments

The arguments to the predicates must belong to known Visual Prolog domains. A domain can be a standard domain, or it can be one you declare in the domains section.

Examples

If you declare a predicate my_predicate(symbol, integer) in the predicates section, like this:

PREDICATES
    my_predicate(symbol, integer)

you don't need to declare its arguments' domains in a domains section, because symbol and integer are standard domains. But if you declare a predicate my_predicate(name, number) in the predicates section, like this:

PREDICATES
   my_predicate(name, number)

you will need to declare suitable domains for name and number. Assuming you want these to be symbol and integer respectively, the domain declaration looks like this:

DOMAINS
   name = symbol
   number = integer

PREDICATES
   my_predicate(name, number)

This program excerpt shows some more predicate and domain declarations:

DOMAINS
   person, activity = symbol
   car, make, color = symbol
   mileage, years_on_road, cost = integer

PREDICATES
   likes(person, activity)
   parent(person, person)
   can_buy(person, car)
   car(make, mileage, years_on_road, color, cost)
   green(symbol)
ranking(symbol, integer)

This excerpt specifies the following information about these predicates and their arguments:

The predicate likes takes two arguments (person and activity), both of which belong to unique symbol domains (which means that their values are names rather than numbers).

The predicate parent takes two person arguments, where person is a symbol type.

The predicate can_buy takes two arguments, person and car, which are also both symbol types.

The predicate car takes five arguments: make and color are of unique symbol domains, while mileage, years_on_road, and cost are of unique integer domains.

The predicate green takes one argument, a symbol: there is no need to declare the argument's type, because it's of the standard domain symbol.

The predicate ranking takes two arguments, both of which belong to standard domains (symbol and integer), so there is no need to declare the argument types.

Chapter 5, "Simple and Compound Objects," gives more detail about domain declarations.

In traditional Prolog there is only one type; the term. We have the same in Visual Prolog, but we are declaring what the domains of the arguments to the predicates actually are.

Domains enable you to give distinctive names to different kinds of data that would otherwise look alike. In a Visual Prolog program, objects in a relation (the arguments to a predicate) belong to domains; these can be pre-defined domains, or special domains that you specify.

The domains section serves two very useful purposes. First, you can give meaningful names to domains even if, internally, they are the same as domains that already exist. Second, special domain declarations are used to declare data structures that are not defined by the standard domains.

It is sometimes useful to declare a domain when you want to clarify portions of the predicates section. Declaring your own domains helps document the predicates that you define by giving a useful name to the argument type.

Examples

Here's an example to illustrate how declaring domains helps to document your predicates:

    Frank is a male who is 45 years old.

With the pre-defined domains, you come up with the following predicate declaration:

    person(symbol, symbol, integer)

This declaration will work fine for most purposes. But suppose you want to maintain your code months after you've finished writing it. The preceding predicate declaration won't mean much to you in six months. Instead, the following declarations will help you understand what the arguments in the predicate declaration stand for:

    DOMAINS
       name, sex = symbol
       age       = integer

    PREDICATES
       person(name, sex, age)

One of the main advantages of this declarations, is that Visual Prolog can catch type errors, like the following obvious mistake:

    same_sex(X, Y) :-
       person(X, Sex, _),
       person(Sex, Y, _).

Even though name and sex are both defined as symbol, they are not equivalent to each other. This enables Visual Prolog to detect an error if you accidentally swap them. This feature is very useful when your programs get large and complex.

You might be wondering why we don't use special domains for all argument declarations, since special domains communicate the meaning of the argument so much better. The answer is that once an argument is typed to a specific domain, that domain can't be mixed with another domain you have declared, even if the domains are the same! So, even though name and sex are of the same domain (symbol), they can't be mixed. However, all user-defined domains can be matched with the pre-defined domains.

This next example program will yield a type error when run:

/* Program ch03e01.pro */