## 4.24 Operators

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 advised mechanism of 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).

[ISO]op(+Precedence, +Type, :Name)
  Declare Name to be an operator of type Type with precedence Precedence. Name can also be a list of names, in which case all elements of the list are declared to be identical operators. Precedence is an integer between 0 and 1200. Precedence 0 removes the declaration. Type is one of: `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. Note that although all operators can be redefined by the user, this is strongly discouraged as it often leads to syntax errors or even different semantic interpretations when loading system libraries. It is adviced to keep operators local to modules and load the system modules you need before changing operators.

  1200 | xfx | `-->`, `:-`
  1200 | fx | `:-`, `?-`
  1150 | fx | dynamic, discontiguous, initialization, 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

[ISO]current_op(?Precedence, ?Type, ?:Name)
  True if Name is currently defined as an operator of type Type with precedence Precedence. See also op/3.