Circular predicate usage from different modules.

[Kapelianovych]

I am trying to learn Prolog by writing some random stuff. Currently I am implementing a simple parser. I have modules string.pl and expression.pl with next approximated content:

:- module(string, [string/3]).

:- use_module(library(dcgs)).

:- use_module(expression, [expression/3]).

string(string_node(Parts)) -->
  "'",
  string_(Parts),
  "'".

string_([Part | Parts]) -->
  (
    interpolated_expression(Part)
    ; static_character(Part)
  ),
  string_(Parts).

interpolated_expression(Part) -->
  "${",
  expression(Part),
  "}".

static_character(Character) -->
  [Character],
  {
    Character \= '\'',
    Character \= '$'
  }.

:- module(expression, [expression/3]).

:- use_module(library(dcgs)).

:- use_module(string, [string/3]).

expression(Node) -->
  string(Node).

Unfortunately, there is a cyclic dependency string -> expression -> string -> ... which Scryer complains about (by showing weird file_descriptor error). I tried to pass expression atom as a parameter to the string predicate to invert the dependency.

:- module(string, [string/4]).

:- use_module(library(dcgs)).

string(Functor, string_node(Parts)) -->
  "'",
  string_(Functor, Parts),
  "'".

string_(Functor, [Part | Parts]) -->
  (
    interpolated_expression(Functor, Part)
    ; static_character(Part)
  ),
  string_(Functor, Parts).

interpolated_expression(Functor, Part) -->
  "${",
  { E =.. [Functor, Part] },
  E,
  "}".

% Bottom part of the code is identical.

But Scryer complains that expression procedure does not exist when I pass it to string in the expression module. The last resort is to combine all the code into one module, but I would like to avoid that because it will be bloated. Could there be any other solution to this problem?

P.S.: I omitted some code for brevity to highlight the problem and to not introduce unnecessary complications to the examples.

[triska]

Could you please include the exact query you used and the exact error Scryer yields? Thank you a lot!

[Kapelianovych]

Sure.
Top-level is started in the next way: scryer-prolog expression.pl.
Query is phrase(expression(A), "'foo ${'1'}'")..
First error (having use_module(expression, ...)). and use_module(string, ...) in respective files:

error(resource_error(file_descriptors),open/4).

Second error (passing expression atom as the parameter):

error(existence_error(procedure,expression/3),expression/3).

[triska]

I get:

$ scryer-prolog expression.pl
?- phrase(expression(A), "'foo ${'1'}'").
   error(existence_error(procedure,string/3),string/3).

This is because string/3 is not available in expression.pl. string.pl exports string/4, but not string/3.

To make the problem reproducible, please show the exact files you used, the exact query you used, and the answer you get, analogous to the way I used above, i.e., copying the toplevel interaction. Thank you a lot!

[Kapelianovych]

Okay. Sorry for the inconvenience.
The file tree is next:

project-root
|__ expression.pl
|__ string.pl

First situation.

expression.pl's content:

:- module(expression, [expression/3]).

:- use_module(library(dcgs)).

:- use_module(string, [string/3]).

expression(Node) -->
  string(Node).

string.pl's content:

:- module(string, [string/3]).

:- use_module(library(dcgs)).

:- use_module(expression, [expression/3]).

string(string_node(Parts)) -->
  "'",
  string_(Parts),
  "'".

string_([]) --> [].
string_([Part | Parts]) -->
  (
    interpolation(Part)
    ; static_character(Part)
  ),
  string_(Parts).

interpolation(Part) -->
  "${",
  expression(Part),
  "}".

static_character(Character) -->
  [Character],
  {
    Character \= '\'',
    Character \= '$'
  }.

Testing:

$ scryer-prolog expression.pl
   error(resource_error(file_descriptors),open/4).
?- 

Error is shown before I get the chance to run any query.

Second situation

expression.pl's content:

:- module(expression, [expression/3]).

:- use_module(library(dcgs)).

:- use_module(string, [string/4]).

expression(Node) -->
  string(expression, Node).

string.pl's content:

:- module(string, [string/4]).

:- use_module(library(dcgs)).

string(Functor, string_node(Parts)) -->
  "'",
  string_(Functor, Parts),
  "'".

string_(_, []) --> [].
string_(Functor, [Part | Parts]) -->
  (
    interpolation(Functor, Part)
    ; static_character(Part)
  ),
  string_(Functor, Parts).

interpolation(Functor, Part) -->
  "${",
  { E =.. [Functor, Part] },
  E,
  "}".

static_character(Character) -->
  [Character],
  {
    Character \= '\'',
    Character \= '$'
  }.

Testing:

$ scryer-prolog expression.pl
?- phrase(expression(A), "'foo'").
   A = string_node("foo")
;  false.

Works as intended.

$ scryer-prolog expression.pl
?- phrase(expression(A), "'foo ${'1'}'").
   error(existence_error(procedure,expression/3),expression/3).

Error is thrown while parsing interpolation part I suppose.

[triska]

It seems this is one of the very first use cases of higher-order phrase//N non-terminals! Very nice!

First, why the existence error? It occurs because expression/3 is not available in the context of the string module. No problem, we can make Scryer automatically add the required module-qualification with a meta_predicate/1 declaration in module string:

:- meta_predicate(string(2, ?, ?, ?)).

When we do this, then Scryer will automatically add the required module-prefix, and it will be as if you had written the invocation of string//2 as: string(expression:expression, Node).

But then we get:

?- phrase(expression(A), "'foo ${'1'}'").
   error(type_error(atom,expression:expression),(=..)/2).

Why? Because the logic with (=..)/2 no longer works if a module-prefix is present!

So, we use higher-order phrase//N, as follows:

interpolation(Functor, Part) -->
  "${",
  phrase(Functor, Part),
  "}".

And now we get:

?- phrase(expression(A), "'foo ${'1'}'").
   A = string_node([f,o,o,' ',string_node("1")])
;  false.

[triska]

One smaller point: Consider using dif/2 to make your code more general. This example may help:

?- maplist(dif(Character), "'$").
   dif:dif(Character,$), dif:dif(Character,'\'').

[Kapelianovych]

Wow... I suspected that expression might not be accessible from the string module and I tried to pass expression with module prefix explicitly, but I would never think that =.. will work differently because of that. And I definitely would not think about adding meta_predicate declaration (even though I watched your video about it about two hours ago).

That is a huge help! Thank you 🙏

[triska]

You are welcome, thank you a lot for posting a very interesting example, please keep up the work!

Regarding (=..)/2, please consider:

?- E =.. [expression, Part].
   E = expression(Part).
?- E =.. [expression:expression, Part].
   error(type_error(atom,expression:expression),(=..)/2).

An explicit module qualification should ideally never be necessary. (Ideally!) Indeed the meta_predicate/1 declaration should be used instead.