Node:Compound Terms, Previous:Variables, Up:Terms

Compound Terms

The structured data objects of the language are the compound terms. A compound term comprises a functor (called the principal functor of the term) and a sequence of one or more terms called arguments. A functor is characterized by its name, which is an atom, and its arity or number of arguments. For example the compound term whose functor is named point of arity 3, with arguments X, Y and Z, is written

point(X, Y, Z)

Note that an atom is considered to be a functor of arity 0.

Functors are generally analogous to common nouns in natural language. One may think of a functor as a record type and the arguments of a compound term as the fields of a record. Compound terms are usefully pictured as trees. For example, the term


would be pictured as the compound term

     /   \
  np       vp
  |       /  \
john     v     np
         |     |
       likes  mary

Sometimes it is convenient to write certain functors as operators--2-ary functors may be declared as infix operators and 1-ary functors as prefix or postfix operators. Thus it is possible to write e.g.:

X+Y     (P;Q)     X<Y      +X     P;

as optional alternatives to

+(X,Y)   ;(P,Q)   <(X,Y)   +(X)   ;(P)

The use of operators is described fully below (see Operators).

Lists form an important class of data structures in Prolog. They are essentially the same as the lists of LISP: a list either is the atom [] representing the empty list, or is a compound term with functor . and two arguments, which are respectively the head and tail of the list. Thus a list of the first three natural numbers is the compound term

 / \
1    .
    / \
   2    .
       / \
      3   []

which could be written, using the standard syntax, as


but which is normally written, in a special list notation, as


The special list notation in the case when the tail of a list is a variable is exemplified by

[X|L]     [a,b|L]


   .               .
  / \             / \
X     L         a     .
                     / \
                   b     L


Note that this notation does not add any new power to the language; it simply makes it more readable. e.g. the above examples could equally be written

.(X,L)    .(a,.(b,L))

For convenience, a further notational variant is allowed for lists of integers that correspond to character codes or one-char atoms. Lists written in this notation are called strings. E.g.:


which, by default, denotes exactly the same list as


The Prolog flag double_quotes can be used to change the way strings are interpreted. The default value of the flag is codes, which implies the above interpretation. If the flag is set to chars, a string is transformed to a char-list. E.g. with this setting the above string represents the list:


Finally if double_quotes has the value atom, then the string is made equivalent to the atom formed from its characters: the above sample string is then the same as the atom 'SICStus'.

Unless character escapes have been switched off, backslashes in the sequence denote escape sequences (see Escape Sequences). As for quoted atoms, if a double quote character is included in the sequence it must be escaped, e.g. "can\"t".