>> 3) all predicates work in all-modes, all the time

I think this is the feature that is the most sorely missed in Prolog programming
and as you say it is possible to have it, but only if one is prepared to jump
through no end of hoops. Sometimes it's just not possbile with any reasonable
amount of effort and any sensible amount of coding. This feature is also the one
most characteristic of relations, rather than functions, or the demi-functions
that Prolog predicate definitions end up as (i.e. with more or less standard
inputs and outputs, a.k.a. modes).

I think I detect a hint of frustration in your comment, perhaps after one too
many encounter with recalcitrant Prolog programmers, unwilling to give up their
convenient hacks :)

Well, these days I can wear another hat, that of the ILP researcher, and there
is an interesting use of modes in ILP: they are often used to reduce the size of
the hypothesis search space. Because, of course, the hypothesis space for the
program append(+,+,-) is much smaller than the hypothesis space for the program
append(?,?,?)! Aleph, probably the best-known ILP system of all time (and its
ancestor, Progol) has a special syntax of "mode declarations" to determine input
and output modes, for this reason.

Interestingly, the more recent approach (attention: I'm about to talk about
my PhD work :) of Meta-Interpretive Learning (MIL), does away with specific modes
and Aleph and Progol's (and many other systems') mode declarations. Instead, MIL
encodes inductive bias by means of second-order datalog clauses, the "metarules"
(e.g. ∃P,Q,R,X ∀x,y,z: P(x,y) ← Q(x,z), R(z,y,X) is a metarule with second-order
variables P,Q,R existentially quantified over the set of predicates, first-order
variable X existentially quantified over the set of constants and first-order
variables x,y,z universally quantified over constants). Metarules do not specify
input and output modes -they are, after all, datalog. This would normally blow
up the hypothesis space to unsearchable proportions, but this is managed in
various ways- and an actual search of the hypothesis space (i.e. the set of sets
of clauses) can be avoided alltogether, for a polynomial time learning approach.

But I digress. What I mean to say is that this theoretically mode-free learning
has so far only been implementedin Prolog [1][2][3] or ASP [4]. ASP is purely
declarative, but incomplete in its own way (because the Herbrand base must be
fully ground, which is impossible to do for infinite Herbrand bases) and Prolog
has- the mode problem we discussed. So while we have a powerful learning
approach, with a nice theoretical basis, in practice we implement it in a less
than satisfying manner, always. And, I dare say I've seen the result in annoying
"edge cases". So, after our discussion, I wonder if a minikanren implementation
of MIL would overcome the limitations of the Prolog and ASP implementations -
even at the cost of expensive occurs-checks etc. I mean, at least if one gives
up efficiency, there should be an equally important reward, and an in-practice
realisation of the in-principle soundness and completeness of the approach would
probably be that. In my opinion anyway. At the very least it's a more
compelling reason to re-implement a system in a new language than "well, it's an
implementation in a new language".

Food for thought, post-thesis :)

____________

[1] Metagol:

https://github.com/metagol/metagol

(Try to ignore the scary header)

[2] Thelma:

https://github.com/stassa/thelma

[3] Louise:

https://github.com/stassa/louise

[4] Hexmil:

https://arxiv.org/abs/1805.00068