In general, using any of the mentioned predicates (->)/2, (\+)/1 or !/0 in Prolog code destroys essential properties we expect from classical logic, and therefore complicates declarative reasoning about the code to such an extent that it can be said to prevent it entirely.

For example, both versions of foo/2 that are shown above suffer from the same core deficiency: If some_condition/1 has multiple solutions, then they are cut away and not generated at all. Therefore, for the most general query,

?- foo(X, Y).

only a single answer, or a proper subset of all answers one would expect when reading (->)/2 as "implies", may be shown where, under a declarative reading based on first-order logic, there ought to be more.

This is problematic because if any concrete solution S is cut off due to this deficiency, we can still force the Prolog system to yield it with:

?- X = S, foo(X, Y).

So, we are in the situation that adding a constraint (X = S) yields a solution that is not shown when the constraint is removed. In other words, a specialized version of the predicate is more general than the original definition. This violates monotonicity, which is an essential property of classical first-order logic, and the basis for declarative debugging approaches that let us reason about the location of mistakes in Prolog predicates.

To write good declarative Prolog code that is also efficient, we first need to find and implement the mechanisms that let us express predicates like foo/2 in such a way that they are efficient while retaining their generality as logical relations.

One important building block pertaining to this concrete example was recently found with the new language construct if_/3, described in Indexing dif/2 by Ulrich Neumerkel and Stefan Kral:

https://arxiv.org/abs/1607.01590

With if_/3, we can write foo/2 as:

foo(X, Y) :-
if_(some_condition(X),
bar(Y, X)
baz(X, Y)).

The only requirement for this to work is to have a reified version of some_condition/1, in such a way that we can tell, from the implicit second argument, whether the condition holds or not, while still generating all answers for the most general query.

Some predicates are already reified in the library, so we can write for example:

?- X = a, if_(X = a, Y = b, Y = c).
X = a,
Y = b.

which succeeds without leaving choice-points, and that is good for performance. At the same time, we get both answers (X = a and also dif(X, a), i.e., X is not equal to a) on backtracking if we omit the first goal:

?- if_(X = a, Y = b, Y = c).
X = a,
Y = b ;
Y = c,
dif(X, a).

Hence, the predicate retains important logical properties we expect from first-order logic, and this allows declarative reading and debugging based on these properties.

To benefit from the true power of Prolog, such constructs must become available in Prolog implementations. For example, currently, the only Prolog system that ships with if_/3 as a built-in feature is Mark Thom's Scryer Prolog, where if_/3 and related predicates are available in library(reif):

https://github.com/mthom/scryer-prolog

https://github.com/mthom/scryer-prolog/blob/master/src/prolo...

Other features that are necessary to make Prolog programs more declarative include CLP(ℤ) constraints, pure I/O, efficient implementation of partial strings as lists of characters etc., all of which are currently work in progress and as of yet only partially available in some Prolog systems. Over time, such features will become more widely available, and then they can be more easily taught and used to obtain Prolog programs that are pure and efficient.