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 lead to 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. 
This is an extension specific to SWI-Prolog and the recommended 
mechanism if portability is not an important concern.
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 systems:
:- module(prove,
          [ prove/1
          ]).
:- op(900, xfx, user:(=>)).
Unlike what many users think, operators and quoted atoms have no relation: defining an atom as an operator does not influence parsing characters into atoms and quoting an atom does not stop it from acting as an operator. To stop an atom acting as an operator, enclose it in braces like this: (myop).
xf, yf,
xfx, xfy, yfx, yfy, 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 brackets ( ... ) has 
precedence 0.
The predefined operators are shown in table 4. The ISO standard allows for redefining all operators except the comma (,). Applications must be extremely 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.
In SWI-Prolog, operators are local to a module (see also
section 5.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 
4 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 from operator changes 
to the user module.
| 1200 | xfx | -->,:- | 
| 1200 | fx | :-,?- | 
| 1150 | fx | dynamic, discontiguous, initialization, meta_predicate, module_transparent, multifile, thread_local, volatile | 
| 1100 | xfy | ;,| | 
| 1050 | xfy | ->, 
op*-> | 
| 1000 | xfy | , | 
| 900 | fy | \+ | 
| 900 | fx | ~ | 
| 700 | xfx | <,=,=..,=@=,=:=,=<,==,=\=,>,>=,@<,@=<,@>,@>=,\=,\==, is | 
| 600 | xfy | : | 
| 500 | yfx | +,-,/\,\/, xor,>< | 
| 500 | fx | ? | 
| 400 | yfx | *,/,//, rdiv,<<,>>, mod, rem | 
| 200 | xfx | ** | 
| 200 | xfy | ^ | 
| 200 | fy | +,-,\ | 
| Table 4 : System operators |