Operators are defined to improve the readability of source code. For
example, without operators, to write 2*3+4*5 one would have
to write +(*(2,3),*(4,5)). In Prolog, a number of operators
have been predefined. All operators, except for the comma (,) can be
redefined by the user.
Some care has to be taken
before defining new operators. Defining too many operators might make
your source `natural' looking, but at the same time make it hard to
understand the limits of your syntax. To ease the pain, as of SWI-Prolog
3.3.0, operators are local to the module in which they are defined.
Operators can be exported from modules using a term
op(Precedence, Type, Name) in the export list as specified
by
module/2.
Many modern Prolog systems have module specific operators.
Unfortunately, there is no established interface for exporting and
importing operators. SWI-Prolog's convention has been addopted by YAP.
The module table of the module user acts as default
table for all modules and can be modified explicitly from inside a
module to achieve compatibility with other Prolog that do not have
module-local operators:
:- module(prove,
[ prove/1
]).
:- op(900, xfx, user:(=>)).
In SWI-Prolog, a quoted atom never acts as an operator. Note that the portable way to stop an atom acting as an operator is to enclose it in parentheses like this: (myop). See also section 5.3.1.
xf, yf,
xfx, xfy, yfx, fy or
fx. The `f' indicates the position of the
functor, while
x and y indicate the position of the
arguments. `y' should be interpreted as ``on this position
a term with precedence lower or equal to the precedence of the functor
should occur''. For `x' the precedence of the argument must
be strictly lower. The precedence of a term is 0, unless its principal
functor is an operator, in which case the precedence is the precedence
of this operator. A term enclosed in parentheses ( ... )
has precedence 0.
The predefined operators are shown in table 5. Operators can be redefined, unless prohibited by one of the limitations below. Applications must be careful with (re-)defining operators because changing operators may cause (other) files to be interpreted differently. Often this will lead to a syntax error. In other cases, text is read silently into a different term which may lead to subtle and difficult to track errors.
',').
|) can only be (re-)defined as infix operator
with priority not less than 1001.
[]) or the
curly-bracket pair ({}) as operators.
In SWI-Prolog, operators are local to a module (see also
section 6.8). Keeping operators
in modules and using controlled import/export of operators as described
with the module/2
directive keep the issues manageable. The module system
provides the operators from table
5 and these operators cannot be modified. Files that are loaded from
the SWI-Prolog directories resolve operators and predicates from this system
module rather than user, which makes the semantics of the
library and development system modules independent of operator changes
to the user module.
| 1200 | xfx | -->, :- |
| 1200 | fx | :-, ?- |
| 1150 | fx | dynamic, discontiguous, initialization, meta_predicate, module_transparent, multifile, public, thread_local, thread_initialization, volatile |
| 1100 | xfy | ;, | |
| 1050 | xfy | ->, *-> |
| 1000 | xfy | , |
| 990 | xfx | := |
| 900 | fy | \+ |
| 700 | xfx | <, =, =.., =@=, \=@=,
=:=, =<, ==,
=\=, >, >=, @<, @=<, @>,
@>=, \=, \==, as, is,
>:<, :<
|
| 600 | xfy | : |
| 500 | yfx | +, -, /\, \/, xor |
| 500 | fx | ? |
| 400 | yfx | *, /, //, div, rdiv,
<<, >>, mod, rem |
| 200 | xfx | ** |
| 200 | xfy | ^ |
| 200 | fy | +, -, \ |
| 100 | yfx | . |
| 1 | fx | $ |