Meta-interpreters for dynamic dispatch with call/n

[dnmfarrell]

I've been trying to write a reduce/foldl which works in either direction, and have the following code, which works fine afaict. But I cannot run it in a meta-interpreter because it uses call/5 which is not public.

As I understand it, call/n is a builtin, and therefore cannot be made public. If I try defining my own call_ using =.., then that also errors as =.. is not public (error(permission_error(access,private_procedure,(=..)/2),clause/2)).

Is there a way to write an mi that processes goals containing call/n clauses?

:- use_module(library(clpz)).
:- dynamic(reduce/4).
:- dynamic(sum_/4).

reduce(_, [], Acc, Acc).
reduce(F, [A|As], Acc, D) :-
  call(F, Acc, A, Acc1, D),
  reduce(F, As, Acc1, D).

sum_(A, B, C, Max) :-
  nonvar(Max) ->
    (
      A #>= 0,
      B #> 0,
      C in 1..Max,
      indomain(C),
      C #= A + B
    );
    C #= A + B.

[bakaq]

What exactly are you doing in your meta-interpreter that needs the predicate to be public? Are you using clause/2 or something similar to get the body of a predicate to meta-interpret? I feel like just passing the source code as an argument may be a better idea.

But anyway, I think you can just special case call/n or (=..)/2 or any other predicate in your meta-interpreter so that you just trust it and don't need to introspect into it's definition.

[dnmfarrell]

Here's the revised code which special cases call/5 for this specific example, and now works. Thanks again @bakaq 🥳

:- use_module(library(clpz)).
:- dynamic(reduce/4).
:- dynamic(sum_/4).

reduce(_, [], Acc, Acc).

reduce(F, [A|As], Acc, D) :-
  call(F, Acc, A, Acc1, D),
  reduce(F, As, Acc1, D).

sum_(A, B, C, Max) :-
  nonvar(Max) ->
    (
      A #>= 0,
      B #> 0,
      C in 1..Max,
      indomain(C),
      C #= A + B
    );
    C #= A + B.

mi(true).
mi((A,B)) :-
  mi(A),
  mi(B).
mi(g(G)) :-
  G = call(_,_,_,_,_) -> G; % don't inspect call/5, evaluate it
  (
    mi_clause(G, Body),
    mi(Body)
  ).

mi_clause(G, Body) :-
  clause(G, B),
  defaulty_better(B, Body).

defaulty_better(true, true).
defaulty_better((A,B), (BA,BB)) :-
  defaulty_better(A, BA),
  defaulty_better(B, BB).
defaulty_better(G, g(G)) :-
  G \= true,
  G \= (_,_).

[jjtolton]

mi(g(G)) :-

G = call(,,,,_) -> G; % don't inspect call/5, evaluate it

(

mi_clause(G, Body),

mi(Body)

).

Interesting... can you explain this technique?

[jjtolton]

Ah ok, nevermind I got it. The G=call(...) syntax put my brain into procedural mode for a minute, I realize you are matching against that structure now 😵‍💫

[UWN]

G = call(_,_,_,_,_) -> G; % don't inspect call/5, evaluate it

Which means that there is no meta-interpretation for the goal that in called here.

[jjtolton]

G = call(_,_,_,_,_) -> G; % don't inspect call/5, evaluate it

Which means that there is no meta-interpretation for the goal that in called here.

Nuanced point, I missed that, thank you!