Querying Prolog code with Prolog?

[jjtolton]

I often tout that one of the major advantages of Prolog over other programming languages, even my beloved lisp, is the queryablity of code. After all, Prolog code is Prolog data! However, it strikes me that I don't actually know how to do this.

I'm sure it's probably quite straight forward. I imagine it would be something like,

1. read file
2. convert file to prolog data
3. "iterate" over terms with "pattern matching"...?

As you can see, my terminology gets a little shaky/procedural towards the end. Does anyone have any suggestions?

[hurufu]

read_term/3 reads text file using the same parser as when you compile your program. In one of my projects I did something like this:

:- initialization(main).

main :-
    slurp('example.pl', T),
    maplist(assertkb, T).

assertkb(T) :-
    T = (H :- B) -> (
        once(list_sequence(L, B)),
        assertz(kb(H, L))
    ); (
        T = (':-'(B)) ->
            true
        ;   assertz(kb(T, []))
    ).

slurp(File, VTs) :-
    open_call_close(collect_vars_terms(VTs), read, [type(text)], File).

collect_vars_terms(VTs, Stream) :-
    findall([Vs,T], read_term_cp(Stream, T, [variable_names(Vs)]), VTs).


read_term_cp(Stream, Term, Options) :-
    read_term(Stream, Term, Options), Term \== end_of_file -> true; !.
read_term_cp(Stream, Term, Options) :-
    read_term_cp(Stream, Term, Options).

open_call_close(G_1, Method, Options, File) :-
    setup_call_cleanup(
        open(File, Method, Stream, Options),
        call(G_1, Stream),
        close(Stream)).

Given you have file 'example.pl' then by calling main/0 whole file will be loaded into database as kb(HeadVariables, Clause). facts.

[jjtolton]

Yeah it's not grabbing the end_of_stream token. 🤔

Is this a bug or user error?

:- use_module(library(iso_ext)).
:- use_module(library(lambda)).
:- use_module(library(format)).
:- use_module(library(reif)).
:- use_module(library(dif)).
:- use_module(library(debug)).


findall_terms_(Stream, Terms0, Terms) :-
        catch(read_term(Stream, Term, []),
              _,
              Term=end_of_file
             ),
        if_(Term=end_of_file,
            [Term|Terms0]=Terms,
            findall_terms_(Stream, [Term|Terms0], Terms)
           ).

findall_terms(Stream, Terms) :-
        findall_terms_(Stream, [], Terms).

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   ?- Terms+\(setup_call_cleanup(open("/tmp/warmup.pl", read, Stream),
                      findall_terms(Stream, Terms),
                      close(Stream)
                     )).
   %@    Terms = [end_of_file,(findall_terms(_A,_B):-findall_terms_(_A,[],_B)),(findall_terms_(_C,_D,_E):-catch(read_term(_C,_F,[]),_G,_F=end_of_file),if_(_F=end_of_file,[_F|_D]=_E,findall_terms_(_C,[_F|_D],_E))),(:-use_module(library(debug))),(:-use_module(library(dif))),(:-use_module(library(reif))),(:-use_module(library(format))),(:-use_module(library(lambda))),(:-use_module(library(iso_ext)))].
   
      
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

[hurufu]

If file that your program reads contains a syntax error it will throw an exception and you won't receive end_of_file atom.

[jjtolton]

Ok, I see what's happening. I haven't checked the source code yet, but it seems that read_term/3 does not unify with end_of_file. I do not think there is a syntax error, I think that is being misreported.

It works when I explicitly put end_of_file as the last term in the file!

:- use_module(library(iso_ext)).
:- use_module(library(lambda)).
:- use_module(library(format)).
:- use_module(library(reif)).
:- use_module(library(dif)).
:- use_module(library(debug)).




findall_terms_(Stream, Terms0, Terms) :-
        read_term(Stream, Term, []),
        if_(Term=end_of_file,
            [Term|Terms0]=Terms,
            findall_terms_(Stream, [Term|Terms0], Terms)
           ).

findall_terms(Stream, Terms) :-
        findall_terms_(Stream, [], Terms).

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   ?- Terms+\(setup_call_cleanup(open("/tmp/warmup.pl", read, Stream),
                      findall_terms(Stream, Terms),
                      close(Stream)
                     )).
   %@    Terms = [end_of_file,(findall_terms(_A,_B):-findall_terms_(_A,[],_B)),(findall_terms_(_C,_D,_E):-read_term(_C,_F,[]),if_(_F=end_of_file,[_F|_D]=_E,findall_terms_(_C,[_F|_D],_E))),(:-use_module(library(debug))),(:-use_module(library(dif))),(:-use_module(library(reif))),(:-use_module(library(format))),(:-use_module(library(lambda))),(:-use_module(library(iso_ext)))].
   
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

end_of_file.

[jjtolton]

For lack of a better answer, I'm going to go with this approach as the best current concise fully working answer for reading in a list of terms in a file in Scryer Prolog. Happy to relabel that if anyone has a different suggestion. Thanks to @hurufu for revealing the meat of the technique.

%% /tmp/warmup.pl
:- use_module(library(iso_ext)).
:- use_module(library(lambda)).
:- use_module(library(format)).
:- use_module(library(reif)).
:- use_module(library(dif)).
:- use_module(library(debug)).

slurp_terms_(Stream, Terms0, Terms) :-
        catch((read_term(Stream, Term, []),
               slurp_terms_(Stream, [Term|Terms0], Terms)
              ),
              error(syntax_error(incomplete_reduction), _),
              Terms=[end_of_file|Terms0]
             ).
        
slurp_terms(Stream, Terms) :-
        slurp_terms_(Stream, [], Terms).

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   ?- Terms+\(setup_call_cleanup(open("/tmp/warmup.pl", read, Stream),
                      slurp_terms(Stream, Terms),
                      close(Stream)
                     )).
   %@    Terms = [end_of_file,(slurp_terms(_A,_B):-slurp_terms_(_A,[],_B)),(slurp_terms_(_C,_D,_E):-catch((read_term(_C,_F,[]),slurp_terms_(_C,[_F|_D],_E)),error(syntax_error(incomplete_reduction),_G),_E=[end_of_file|_D])),(:-use_module(library(debug))),(:-use_module(library(dif))),(:-use_module(library(reif))),(:-use_module(library(format))),(:-use_module(library(lambda))),(:-use_module(library(iso_ext)))].
   - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

[triska]

In addition, clauses of public procedures can be inspected with clause/2. For example:

:- dynamic(p/1).   % dynamic implies public

p(Xs) :-
        maplist(=(a), Xs),
        hello.
p(_) :- there.

Yielding:

?- clause(p(X), Body).
   Body = (maplist(=(a),X),hello)
;  Body = there.

[adri326]

On that topic, I had written a small document containing snippets of code for various ways to inspect existing predicates and how they get transformed, on a branch: wiki-expansion-and-inspection.md. I'm sure I got things wrong, but it'd be nice to expand the wiki with it once the inaccuracies are sorted

[triska]

Please also see: #2532 Every contribution and observation is welcome! We know that we definitely need better mechanisms for this.

[hurufu]

If you want to write the shortest possible predicate to read whole file as terms into memory, we can try to play code golf :)

Here is my entry:

:- use_module(library(lambda)).

slurp_in_one_clause(File, Terms) :-
    setup_call_cleanup(
        open(File, read, S, []),
        (
            L = \[A|T]^(copy_term(L,LP), read_term(S,A,[]), (A \= end_of_file -> call(LP, T); !, T = [])),
            call(L, Terms)
        ),
        close(S)
    ).

Remark: I would never write such code in production ;)