A common issue with Prolog programs of a procedural nature
is to guarantee deterministic behaviour and debug possible problems with
determinism. SWI-Prolog provides several mechanisms to make writing,
debugging and maintaining deterministic code easier. One of them is
Single Sided Unification using =>/2 rules as
described in section 5.6.
This section deals with annotating your program.
If a program does not behave according to these annotations it raises
an
error/2 exception where the formal term is
determinism_error(Pred, Declared, Observed, DeclType),
where
Declared is currently always det, Observed
is one of
fail or nondet and DeclType is one of property
(det/1), guard
($/0) or goal
($/1). Using trap/1
or gtrap/1 we
can ask Prolog to start the debugger in such events using
?- gtrap(determinism_error(_,_,_,_)).
WARNING: The primitives in this section are experimental. The
naming and exact semantics may change. If you are interested in this,
please follow and contribute to discussion on the Discourse forum.
- [directive]det(+PredicateIndicators)
- Declare a number of predicates as
det (deterministic).
As a result, both failure and success with a choicepoint is considered
an error. The behaviour if the declaration is violated is controlled
with the Prolog flag determinism_error.
The default is to raise an exception (error). Consider the
following program:
:- det(p/1).
p(1).
p(2).
Now, a call ?- p(1). behaves normally. However:
?- p(X).
ERROR: Deterministic procedure p/1 succeeded with a choicepoint
ERROR: In:
ERROR: [10] p(1)
?- p(a).
ERROR: Deterministic procedure p/1 failed
ERROR: In:
ERROR: [10] p(a)
Violations throw an error/2 exception
determinism_error(Pred, Declared, Observed, property).
The trap/1
(cli) or gtrap/1
(gui) predicate can be used to make the debugger stop near the error.
For example:
?- gtrap(determinism_error(_,_,_,_)).
- [experimental]$
- The $/0 constructs
acts similar to the !/0, but
in addition declares that the remainder of the clause body shall succeed
deterministically. It exploits the same underlying mechanism as the det/1
declaration. See also $/1.
Violations throw an error/2 exception
determinism_error(Pred, Declared, Observed, guard).
- [experimental]$(:Goal)
- Verify that Goal succeeds deterministically. This predicate
has no effect if Goal succeeds without a choicepoint.
Otherwise the result depends on the Prolog flag determinism_error:
- silent
- Act as once/1.
- warning
- Print a warning and act as once/1.
- error
- Raise a
determinism_error exception.
Note that if $/1
is used for the last call, last call optimization is not effective. This
behaviour ensures consistent errors or warnings. Last call optimization
with determinism checking can be realised using ..., $, Last.,
i.e. by executing
$/0 before the
last call rather than wrapping the last call in $/1.
Violations throw an error/2 exception
determinism_error(Pred, Declared, Observed, goal).
A deterministic predicate may call normal predicates. No error is
triggered as long as the deterministic predicate either ignores a
possible failure, e.g., using \+/1
and prunes possible choice points created by called predicates. If the
last predicate is a normal predicate the requirement to succeed
deterministically is transferred to the new goal. As last-call
optimization causes the information which predicate initially claimed to
be deterministic to be lost, the error is associated with the called
predicate. Debug mode (see debug/0
or the Prolog flag debug)
may be used to avoid last call optimization and find the call stack that
causes the issue.
