.\" ------------------------------ sec3.t ------------------------------
.sh 1 "Syntax"
.pp
.sh 2 "Terms"
.pp
The syntax of SB-Prolog is by and large compatible with that of
C-Prolog.
The data objects of the language are called  \fIterm\fPs.
A  term  is either a \fIconstant\fP, a \fIvariable\fP or a \fIcompound term\fP.
Constants can be \fIintegers\fR or \fIatoms\fR.
The symbol for an atom must begin with a lower case letter or the dollar
sign $, and consist of any number of letters, digits, underscores
and dollar signs; if it contains any character other than these, it must be
enclosed within single quotes.\**
.(f
\** Users are advised against using symbols beginning with `$' or `_\|$',
however, in order to minimize the possibility of conflicts with symbols
internal to the system.
.)f
As in other  programming languages,  constants  are definite elementary objects.
.pp
Variables are distinguished by an initial capital  letter  or  by
the initial character \*(lq\(ul\|\*(rq, for example
.(l
X   Value   A   A1   \(ul\|3   \(ul\|RESULT   \(ul\|result
.)l
If a variable is only referred to once, it does not need to  be  named
and  may  be  written as an \fIanonymous\fP variable, indicated by the
underline character \*(lq\(ul\|\*(rq.
.pp
A variable should be thought of as  standing  for  some  definite  but
unidentified  object.
A variable  is  not  simply  a  writeable
storage  location  as  in  most programming languages;  rather it is a
local name for some data object, cf.  the variable of  pure  LISP  and
constant declarations in Pascal.
.pp
The structured data objects of the language are the compound terms.  A
compound term comprises a \fIfunctor\fP (called the \fIprincipal\fP functor of
the term) and a sequence of one or more terms called \fIarguments\fP.
A functor is characterised by its \fIname\fP, which is an atom, and its
\fIarity\fP 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
.(l
point(X,Y,Z)
.)l
An atom is considered to be a functor of arity 0.
.pp
A functor or predicate symbol is uniquely identified by its name and arity
(in other words, it is possible for different symbols having different
arities to share the same name).  A functor or predicate symbol \fIp\fR
with arity \fIn\fR is usually written \fIp\fR/\fIn\fR.
.pp
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
.(l
s(np(john),vp(v(likes),np(mary)))
.)l
would be pictured as the structure
.(b C
       s
     /   \e
   np      vp   
   |      /  \e
 john    v     np
         |     |
       likes  mary
.)b
.pp
Sometimes it is convenient to write certain functors as \fIoperators\fP
\*- 2-ary functors may be declared as \fIinfix\fP operators and 1-ary functors
as \fIprefix\fP or \fIpostfix\fP operators.
Thus it is possible to write
.(l
X+Y     (P;Q)     X<Y      +X     P;
.)l
as optional alternatives to
.(l
+(X,Y)   ;(P,Q)   <(X,Y)   +(X)   ;(P)
.)l
Operators are described fully in the next section.
.pp
\fIList\fPs 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  `.'/2
and  two  arguments  which  are  respectively the head and tail of the
list.  Thus  a  list  of  the  first  three  natural  numbers  is  the
structure
.(b C
  .
 / \e
1    .
    / \e
   2    .
       / \e
      3   []
.)b
which could be written, using the standard syntax, as
.(l
\&.(1,.(2,.(3,[])))
.)l
but which is normally written, in a special list notation, as
[1,2,3].
The special list notation in the case when the tail of  a  list  is  a
variable is exemplified by
.(l
[X|L]     [a,b|L]
.)l
representing
.(b C
   .                .
  / \e             / \e
X     L          a    .
                     / \e
                   b     L
.)b
respectively.
.pp
Note that this list syntax is only syntactic sugar for terms of the form
\&`.'(\(ul\|,\(ul\|) and does not provide any new facilities that were not
available otherwise.
.pp
For convenience, a further  notational  variant  is  allowed  for
lists  of  integers  which correspond to ASCII character codes.  Lists
written in this notation are called \fIstring\fPs.
For example,
.(l
"Prolog"
.)l
represents exactly the same list as
.(l
[80,114,111,108,111,103]
.)l
.sh 2 "Operators"
.pp
Operators in Prolog are simply a notational convenience.
For example, the expression
.(l
2 + 1
.)l
could also be written +(2,1).
It should be noticed that this expression represents the structure
.(b C
   +
 /   \e
2     1
.)b
and not the number 3.
The addition would only be performed if the structure was passed as an
argument to an appropriate procedure (such as \fBeval\fP/2 \- see Section 5.2).
.pp
The Prolog syntax caters for operators  of  three  main  kinds  \-
\fIinfix\fR, \fIprefix\fR and \fIpostfix\fR.
An infix operator appears between its two arguments, while a prefix operator
precedes its single argument and a postfix operator is written after its
single argument.
.pp
Each operator has a \fIprecedence\fP, which is a
number from  1  to  1200.  The  precedence  is  used  to  disambiguate
expressions  where  the  structure  of  the  term  denoted is not made
explicit through parenthesization.   The  general  rule
is that the operator with the
\fIhighest\fP precedence is the principal functor.  Thus if `+'  has  a
higher precedence than `/', then ``a+b/c'' and ``a+(b/c)''
are equivalent and denote the term \*(lq+(a,/(b,c))\*(rq.
Note that the  infix
form of the term \*(lq/(+(a,b),c)\*(rq must be written with explicit
parentheses, ``(a+b)/c''.
.pp
If there are two operators in the subexpression having  the  same
highest  precedence,  the ambiguity must be resolved from the \fItypes\fP of
the operators.  The possible types for an infix operator are
.(l
xfx     xfy     yfx
.)l
With an operator of type `xfx', it is a requirement that both  of  the
two  subexpressions which are the arguments of the operator must be of
\fIlower\fR precedence  than  the  operator  itself,  i.e.   their  principal
functors  must  be  of  lower  precedence, unless the subexpression is
explicitly  bracketed  (which  gives  it  zero  precedence).  With  an
operator of type `xfy', only the first or left-hand subexpression must
be of lower precedence;  the second can be of the \fIsame\fP  precedence  as
the main operator;  and vice versa for an operator of type `yfx'.
.pp
For example, if the operators `+' and `\-' both  have  type  `yfx'
and are of the same precedence, then the expression
``a\-b+c'' is valid, and means ``(a\-b)+c'', i.e. ``+(\-(a,b),c)''.
Note that the expression would be invalid if the  operators  had  type
\&`xfx', and would mean ``a\-(b+c)'', i.e. ``\-(a,+(b,c))'',
if the types were both `xfy'.
.pp
The possible types for a prefix operator are
.(l
fx        fy
.)l
and for a postfix operator they are
.(l
xf        yf
.)l
The meaning of the types should be clear by  analogy  with  those  for
infix  operators.   As  an example, if `not' were declared as a prefix
operator of type `fy', then
.(l
not not P
.)l
would be a permissible way to write \*(lqnot(not(P))\*(rq. If  the  type  were
\&`fx', the preceding expression would not be legal, although
.(l
not P
.)l
would still be a permissible form for \*(lqnot(P)\*(rq.
.pp
In SB-Prolog, a functor named \fIname\fP is  declared  as  an
operator of type \fItype\fP and precedence \fIprecedence\fP by calling
the evaluable predicate \fBop\fP:
.(l
	| ?- op(\fIprecedence\fP,\fItype\fP,\fIname\fP).
.)l
.(x b
(L)	 op/3
.)x
The argument \fIname\fP can also be a list of names of operators of the same
type and precedence.
.pp
It is possible to have more than one operator of the  same  name,
so long as they are of different kinds, i.e.  infix, prefix or postfix.
An operator of any kind may be redefined by a new declaration  of  the
same  kind.   This  applies equally to operators which are provided as
\fIstandard\fP in SB-Prolog, namely:
.(l
.TS
r r r l.
:\- op(	1200,	xfx,	[ :\-, --> ]).
:\- op(	1200,	fx,	[ :\-, ?- ]).
:\- op(	1198,	xfx,	[ ::\- ]).
:\- op(	1100,	xfy,	[ ; ]).
:\- op(	1050,	xfy,	[ \-> ]).
:\- op(	1000,	xfy,	[ ',' ]).   /* See note below */
:\- op(	900,	fy,	[ not, \e+, spy, nospy ]).
:\- op(	700,	xfx,	[ =, is, =.., ==, \e==, @<, @>, @=<, @>=,
\&	\&	\&	  =:=, =\e=, <, >, =<, >= ]).
:\- op(	661,	xfy,	[ `.' ]).
:\- op(	500,	yfx,	[ +, \-, /\e, \e/ ]).
:\- op(	500,	fx,	[ +, \- ]).
:\- op(	400,	yfx,	[ *, /, //, <<, >> ]).
:\- op(	300,	xfx,	[ mod ]).
:\- op(	200,	xfy,	[ ^ ]).
.TE
.)l
.pp
Operator declarations are most usefully placed in directives at the top
of your program files. In this case the directive should be a command as
shown above. Another common method of organisation is to have one file
just containing commands to declare all the necessary operators. This file
is then always consulted first.
.pp
Note that a comma written literally as  a  punctuation  character
can be used as though it were an infix operator of precedence 1000 and
type `xfy':
.(l
X,Y    ','(X,Y)
.)l
represent the same compound term.  But note that a comma written as  a
quoted atom is \fInot\fP a standard operator.
.pp
Note also that the  arguments  of  a  compound  term  written  in
standard  syntax must be expressions of precedence \fIbelow\fP 1000. Thus it
is necessary to parenthesize the expression \*(lqP :\- Q\*(rq in
.(l
assert((P :\- Q))
.)l
The following syntax restrictions serve  to
remove potential ambiguity associated with prefix operators.
.ip -
In a term written in standard syntax, the  principal  functor  and
its  following  \*(lq(\*(rq  must  \fInot\fP be separated by any whitespace.  Thus
.(l
point (X,Y,Z)
.)l
is invalid syntax (unless \fIpoint\fR were declared as a prefix operator).
.ip -
If the argument of a prefix operator starts with a \*(lq(\*(rq,  this  \*(lq(\*(rq
must  be  separated  from  the operator by at least one space or other
non-printable character.  Thus
.(l
:\-(p;q),r.
.)l
(where `:\-' is the prefix operator) is invalid syntax, and must be written as
.(l
:\- (p;q),r.
.)l
.ip -
If a prefix  operator  is  written  without  an  argument,  as  an
ordinary  atom,  the  atom  is  treated  as  an expression of the same
precedence as the prefix operator, and  must  therefore  be  bracketed
where necessary.  Thus the brackets are necessary in
.(l
X = (?-)
.)l
.\" ---------------------- end of sec3.t ----------------------

.