##### Syntax Restrictions

Note carefully the following syntax restrictions, which serve to remove potential ambiguities associated with prefix operators.

1. The arguments of a compound term written in standard syntax must be expressions of precedence less than 1000. Thus it is necessary to write the expression `P:-Q` in parentheses
```          assert((P:-Q))
```

because the precedence of the infix operator `:-`, and hence of the expression `P:-Q`, is 1200. Enclosing the expression in parentheses reduces its precedence to 0.

2. Similarly, the elements of a list written in standard syntax must be expressions of precedence less than 1000. Thus it is necessary to write the expression `P->Q` in parentheses
```          [(P->Q)]
```

because the precedence of the infix operator `->`, and hence of the expression `P->Q`, is 1050. Enclosing the expression in parentheses reduces its precedence to 0.

3. In a term written in standard syntax, the principal functor and its following `(` must not be separated by any intervening spaces, newlines, or other characters. Thus
```          point (X,Y,Z)
```

is invalid syntax.

4. If the argument of a prefix operator starts with a `(`, this `(` must be separated from the operator by at least one space or other layout character. Thus
```          :-(p;q),r.
```

(where `:-` is the prefix operator) is invalid syntax. The system would try to interpret it as the structure:

```                      ,
/ \
:-    r
|
;
/ \
p   q
```

That is, it would take `:-` to be a functor of arity 1. However, since the arguments of a functor are required to be expressions of precedence less than 1000, this interpretation would fail as soon as the `;` (precedence 1100) were encountered.

In contrast, the term:

```          :- (p;q),r.
```

is valid syntax and represents the following structure:

```                      :-
|
,
/ \
;   r
/ \
p   q
```

5. 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 written in parentheses where necessary. Thus the parentheses are necessary in
```          X = (?-)
```

since the precedence of `?-` is 1200.