I'm still in the hammock phases of using logical programming to model function schemas

I think it's a great fit, schemas can totally map to relations, and functions are just joins, which also produce relations

One abortive experiment: https://github.com/bsless/mallilog

Another https://github.com/bsless/malli-keys-relations

The big problem is core.logic can't do set relations

It is a bother, to be sure; but I’ve gotten some useful things done with alists as maps

… list lists as sets and weaving in/out of Clojure space, core.logic space

But the new branch of #CFFTD7R6Z can 🙂

I am not super familiar with meander, and while it may support some pattern matching on sets and maps, I am very skeptical that it encodes a theory of finite sets like you would need for proper handling of sets in core.logic (and set like things like map keys).

I think it does, I remember @U06MDAPTP sent me the papers on it. I can't remember the term but there's a whole set of work around pattern matching collections with no canonical representations. iirc it should even work with multi sets.

Pattern matching is kind of half of unification. Pattern matching has a concrete(ground) structure on one side a pattern on the other. Unification between two sets that you might not know the elements of, and might themselves contain logic variables, is annoying

https://www.egison.org/

Here we go Backtracking pattern matching for non linear data types https://arxiv.org/abs/1808.10603

I mean, that is neat, but it is not relational programming. Pattern matching is unidirectional, where unification has to be done in both directions, which is significantly trickier. https://github.com/namin/clpset-miniKanren is the one implementation of constraint logic programming with sets for minikanren that I am aware of, it based on a paper that formulates set constraints as a series of rewrite rules. The paper is pretty straightforward (if you just take them at their word that the rewrites are sound and ignore any proofs), but figuring how to extend code.logics constraint system is a pain because there are no docs for it

I think that meander/zeta can be run backwards, which might satisfy this requirements But are we complaining about core logic now? I wouldn't mind a well documented implementation with better perf

I periodically start and never finish getting clp(set) working with core.logic, https://twitter.com/hiredman_/status/1353832401005203457 has a screen shot of using the version that was farthest along to being complete (but I think that code was lost in a a filesystem misadventure)

Anyway working on CLP in kanren assumes you read the papers and are intimately familiar with the implementation, yes

Sort of, core.logic's clp stuff takes the minikanren with constraints paper as a starting point, but it implements it using clojure features (protocols, types, etc) so it doesn't end up exactly like what is in the papers (a pretty bare scheme where everything is cons cells)

So when I say core.logic is not well documented, it is the use of clojure features like protocols.

The metadata doesn't make it easier, too

It shows the CLP stuff was added later

That's why I think an implementation with less branches and conditions will be easier to hack on