xfx is useful for defining operators that do not evaluate to a value that has the same type as its operands.

For example, * is yfx because 1 * 3 evaluates to 4, which is of the same type as 1 and 3. However, < is xfx because 1 < 3 evaluates to truth or falsity, which if of a different type than 1 and 3. xfx prevents expressions like `1 < 2 < 3` that are nonsensical in Prolog from being written down.

Some examples and an explainer

About Operators

Doc needs some help

This text is difficult to disentangle:

Type is one of: xf, yf, xfx, xfy, yfx, fy or fx. The‘f’indicates the position of the functor

this should be "functor name"

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.

This is correct but hard to translate into something concrete. Here is mine. Just reduce it to a question of associativity:

op types explained

Finally:

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.

I am not sure this is pertinent. Once the "principal functor" has been identified, the term (or parse tree) has been constructed and the precedence of the operator is no longer relevant for further parsing. All ambiguities involving that operator and its arguments have been resolved, the precedence value of the respective term can be considered 0, the same as if the subexpression with said principal functor had been parenthesized from the start.

If there is a predicate that corresponds to an operator, Prolog calls it

Take precedence 420 which is above the arithemtic operators and make the operator non-associative (it makes no sense to chain it)

?- op(420,xfx,weirdop).
true.

Now you can write terms but there is no meaning associated to them (nothing callable exists):

?- pi weirdop 0.
ERROR: Unknown procedure: (weirdop)/2 (DWIM could not correct goal)

But the syntax is good:

?- T = pi weirdop 0, write_canonical(T).
weirdop(pi,0)
T = pi weirdop 0.

However, if we define predicate weirdop/2:

?- [user].
|: weirdop(X,Y) :- format("Is sin(~q) > sin(~q)?",[X,Y]), sin(X) > sin(Y).
true.

We can call it "directly":

?- pi/2 weirdop 3/4*pi.
Is sin(pi/2) > sin(3/4*pi)?
true.

?- 5/3*pi weirdop 3/4*pi.
Is sin(5/3*pi) > sin(3/4*pi)?
false.

Lopsidedly, this evidently doesn't work if you want to have an operator that maps to a function that returns something other than a boolean (i.e. not a predicate). Then you need an interpreter of the term created from the operator.

Programming fun!

A silly little program to print your current operators can be found here (there should be something like that in the distribution):

list_ops.pl

And one which output the pldoc with URLs below is here:

list_ops_with_urls.pl

The result

On a freshly started SWIPL instance it output these, with their possible meanings (depending on whether what has been read is evaluated or not, and by whom):

(FIX: I found out that ?- is used in the result of term_expansion/2)

?- list_ops_with_urls.

Precedence value 1200 : weakest precedence, most 'rootlike'

• --> xfx DCG head-body separator
• :- fx Directive prefix as used in source code
• :- xfx Clause head-body separator (left-pointing material implication of constructive logic or positive classical logic)
• ?- fx Query prefix as used on the command line

Precedence value 1150

• discontiguous fx Declares a predicate as discontinguous
• dynamic fx Declares a predicate as dynamic
• initialization fx Marks goal to be called after source file has been loaded
• meta_predicate fx Declares a meta-predicate for module export
• module_transparent fx Declares a predicate as meta-predicate. Deprecated.
• multifile fx Informs the system that the specified predicate(s) may be defined over more than one file.
• public fx Instructs the cross-referencer that the predicate can be called
• table fx Declares a predicate as subject to tabling
• thread_initialization fx Marks goal to be called when thread is started
• thread_local fx Declares a predicate as dynamic, but local to the thread
• volatile fx Declares a predicate as not to be saved into a state file

Precedence value 1105

• | xfy Old-school disjunction meta-predicate

Precedence value 1100

• ; xfy Meta-predicate to combine goals into a (constructive) disjunction. Also 'else' part of 'if-then-else'

Precedence value 1050

• *-> xfy Soft-cut
• -> xfy If-Then (and maybe Else)

Precedence value 1000

• , xfy Meta-predicate to combine goals into a conjunction

Precedence value 900

• \+ fy Negation-as-failure operator

Precedence value 800

• := xfx

Precedence value 700

• :< xfx Dict pair selection
• < xfx Arithmetic evaluation followed by less-than test
• = xfx Unification
• =.. xfx Univ operator to assemble/disassemble a compound term
• =:= xfx Arithmetic evaluation followed by equality test
• =< xfx Arithmetic evaluation followed by less-or-equal-than test
• == xfx Term equivalence; also standard order of term equality test
• =@= xfx Term structural equivalence
• =\= xfx Arithmetic evaluation followed by disequality test
• > xfx Arithmetic evaluation followed by greater-than test
• >:< xfx Dict partial unification
• >= xfx Arithmetic evaluation followed by greater-or-equal-than test
• @< xfx Standard order of terms less-than test
• @=< xfx Standard order of terms less-than-or-equal test
• @> xfx Standard order of terms greater-than test
• @>= xfx Standard order of terms greater-than-or-equal test
• \= xfx Unification failure
• \== xfx Term non-equivalence
• \=@= xfx Term structural non-equivalence
• as xfx Particle used to add tabling options after table/1
• is xfx Arithmetic evaluation of RHS followed by unification with LHS

Precedence value 600

• : xfy Module qualification

Precedence value 500

• + yfx Arithmetic addition
• - yfx Arithmetic subtraction
• /\ yfx Bitwise AND
• \/ yfx Bitwise OR

Precedence value 400

• * yfx Arithmetic multiplication
• / yfx Arithmetic division
• // yfx Arithmetic default-rounded integer division
• << yfx Bitwise shift left
• >> yfx Bitwise shift right
• div yfx Arithmetic integer division
• mod yfx Arithmetic modulo (remainder of floored division)
• rdiv yfx Arithmetic rational number division
• rem yfx Arithmetic remainder of integer division
• xor yfx Bitwise XOR

Precedence value 200

• ** xfx Arithmetic exponentiation (float or integer) ('power' in ISO standard)
• + fy Arithmetic unary '+' sign
• - fy Arithmetic unary '-' sign
• \ fy Bitwise negation (one complement)
• ^ xfy Arithmetic exponentiation (float or integer), also existential quantifier for bagof/3, setof/3

Precedence value 100

• . yfx Dict entry dereferencing and dict function call (also char-to-charcode conversion in arithmetic expressions)

Precedence value 1 : strongest precedence, most 'leaflike'

• $ fx At the toplevel, reuse of bindings created by previous goals, as in '$Var'

Listing the operators exported by modules

Very raw:

?-
use_module(library(clpfd)).
bagof(M-Operators,
      module_property(M, exported_operators(Operators)),Bag),
      maplist([A-B]>>format("~q : ~q~n",[A,B]),Bag).

module_property/2 called with exported_operators/1 instantiates Operators with a list of all operators exported all exported operators from a given module. It also enumerates the modules if the first argument is unbound. use_module(library(clpfd)). loads a module which actually exports operators, to get some output.

What's missing?

A predicate to find out which module a certain operator comes from.

Se also: https://stackoverflow.com/questions/66143527/how-do-i-find-out-which-module-a-prolog-operator-comes-from

Paulo Moura proposes this solution:

• Enumerate all modules using current_module/1 (that predicate does not give you the "current module" of the clause that's executing, it checks wether a module is currently loaded or enumerates the loaded modules)
• Use property exported_operators(Operators) to get a list of the operators exported by that module.
• Select those entries matching the atom of the operator

?-
use_module(library(clpfd)).  % Load a library which actually exports operators
true.

?-
current_module(M),
module_property(M, exported_operators(Operators)),
member(op(Priority, Type, '#>'), Operators).

M = clpfd,
Priority = 700,
Type = xfx .

If you need to use library(xpath), beware of the autoloaded declaration from tabling:

?- current_op(X,Y,table).
X = 1150,
Y = fx.

Indeed, it makes your XPATHs containing .../table/... syntactically wrong (or even semantically, I haven't checked).

You can disable the declaration with this directive

:- op(0,fx,table).

I spent few evenings trying to understand how the the x and y work. Finally I got it. I'll try explain by an example.

If we would have two operators op1 with 150 xfy and op2 with 150 xfy, and three variables Q, W and E.

Can the order of (Q op1 W op2 E) be ((Q op1 W) op2 E)? Declaration of op2 says xfy, so the op1 must be of lower precedence. But because 150 (the op1 precedence) is not lower than 150 (the op2 precedence) this choice fails.

Can the order of (Q op1 W op2 E) be (Q op1 (W op2 E))? Declaration of op1 says xfy, so the op2 must have a lower or equal precedence compared to op1. And 150 <= 150 is true so the order is (Q op1 (W op2 E))

`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 word is not easy for understanding. `x' v.s. `y', which has the lower precedence?

See also the Syntax extensions section in of the Hackers corner chapter of the manual. It describes block operators and quasi quotation which fill a need similar to op/3.