Introspection techniques for Scryer Prolog?

[jjtolton]

Does anyone have a good lead on what introspection techniques are available for Scryer Prolog?

I'm trying to work on some tools that might be useful for Scryer. Parsing the code is possible but introspection and reflection tools would be faster.

[hurufu]

What do use exactly mean by introspection? In Prolog code is data, so you don't need any "extra" introspection support. For example when I wrote a call graph generator I just used read_term/3 and then operated on those terms.

[hurufu]

1. Don't know. There is current_module/1, but it can't be freely used (if I understand correctly), only during goal expansion.
2. current_predicate/1
3. clause/2 but only for dynamic predicates
4. N/A
5. library(atts)

During compilation some information about predicates is lost. I think it is a better approach to use read_term/3 and analyze source code directly if you know a source file name.

[jjtolton]

During compilation some information about predicates is lost. I think it is a better approach to use read_term/3 and analyze source code directly if you know a source file name.

Will most likely have to do this.

[jjtolton]

1. Don't know. There is current_module/1, but it can't be freely used (if I understand correctly), only during goal expansion.
2. current_predicate/1
3. clause/2 but only for dynamic predicates
4. N/A
5. library(atts)

During compilation some information about predicates is lost. I think it is a better approach to use read_term/3 and analyze source code directly if you know a source file name.

This was a good tip. The only facility we are really missing is the ability to list modules loaded in memory, I haven't been able to find anything to do that yet. But these help a lot:

  ?- current_predicate(P).
  %@    P = term_expansion/2
  %@ ;  P = verify_attributes/3
  %@ ;  P = goal_expansion/2
  %@ ;  P = project_attributes/2
  %@ ;  P = attribute_goals/3
  %@ ;  ... .

  :- dynamic(yo/2).
  :- dynamic(yo/3).
  
  yo(A,B) :- !.
  yo(x, Y) :- Y=1.
  yo(z, B, Q) :- B=Q.
  yo(1,2,4).

  ;; find all dynamic predicates and bodies
  ?- F^Body+\( 
            (   findall(F, (current_predicate(P/N), functor(F, P, N),
                            catch(clause(F, Body),
                                  error(permission_error(access,private_procedure,_),_),
                                  false
                                 )), Fs),
                member(F, Fs),
                clause(F, Body))
          ).
  %@    F = yo(_A,_B), Body = !
  %@ ;  F = yo(x,_A), Body = (_A=1)
  %@ ;  F = yo(x,_A), Body = !
  %@ ;  F = yo(x,_A), Body = (_A=1)
  %@ ;  F = yo(z,_A,_B), Body = (_A=_B)
  %@ ;  F = yo(1,2,4), Body = true.

There's an easier way to do the second thing, but emacs crashed before I could save the file last night and I forgot what it was 🙄

[jjtolton]

That and something module/3 this would be really nice, I think we'd have enough to make some pretty good dynamic tools that way.

[hurufu]

You can avoid catching exception, by using predicate_property(F, dynamic).

[mthom]

I am writing a decompile program to translate predicates to their WAM code definitions and back again. It would essentially provide listing/1 for static and dynamic predicates alike. I've been very busy these last few months and haven't been able to return to it. Especially now, as I'm about to begin a new job and move to another city on top of preparing two talks for the Scryer Prolog meetup.

[UWN]

Is this decompile really so important? Instead, just saving the term prior to WAM compilation would do the very same (with marginal extra cost for storing that term). And this is only required for public definitions (7.5.3).

[mthom]

My hope is for it to branch into other things, like compiling and analyzing Prolog programs from within Prolog.

[hyperswine]

How does listing/1 work? I tried to list a few things in my file and builtins but it says error(permission_error(access,private_procedure,mypred/2),clause/2).?

[hurufu]

It only works for dynamic predicates. You can declare it by adding this:

:- dynamic(mypred/2).

[UWN]

There is a note in 7.5.4 Private and public procedures:

NOTE — An additional directive public/1 that specifies some
user-defined procedures to be public would be an extension.

I am unaware of a system that does this. And also unsure if this makes sense in the cases in question. There, the public property should be the default for (certain) user defined predicates. This with a clear interface to the non-public part.