String or char to variable? A question that doesn't make sense.

[jjtolton]

I am working on transpiling lisp code to Prolog code. I have a question that I don't have the correct words for, and may not make sense.

For background, I may define a predicate in Clojure syntax as:

(:- (foo ?x ?y) (#= ?y (+ ?x 1))

with the hopes that this would transpile to

foo(X, Y) :- 
    Y #= X + 1.

To make the example really simple, this clearly does not work:

named_vars(VarNameIn, VarNameOut, Pred) :-
        Pred=(foo(VarNameIn, VarNameOut) :- VarNameIn #= VarNameOut + 1).

Would I need to do this with string formatting DCGs...?

I realize this may be asking the wrong question. If someone can help me figure out what the right question is, I'd appreciate it. I realize what I'm trying to do is in some ways nonsensical, it probably doesn't matter what the variables are named so long as they are logically distinct. But I haven't fully wrapped my head around the problem yet.

---

Update

Still confused, my question still doesn't make sense. I'd need to take a string and convert it to named variable, I think.

So,

named_vars(VarNameChar, Pred) :- 
     something.

?- varnamestring_pred("Zebra", Pred).
%@ Pred = foo(Zebra).

This is what I meant to do.

---

Update 2

I think I've narrowed my question down to "how do I implement string_term/2:

variablenamestr_pred(VarNameStr, Pred) :-
        write_term_to_chars(foo('~s'), [], PredString),
        phrase(format_(PredString, [VarNameStr]), PredStringOut, []),
        string_term(PredStringOut, Pred).

If we implement string_term/2 as equality, we get:

variablenamestr_pred(VarNameStr, Pred) :-
        write_term_to_chars(foo('~s'), [], PredString),
        phrase(format_(PredString, [VarNameStr]), PredStringOut, []),
        string_term(PredStringOut, Pred).

string_term(A,B) :- A=B.
                            
?- variablenamestr_pred("Zebra", Pred).
%@    Pred = "foo(Zebra)".

So close!

---

Update 3

After confusing the heck out of everyone, I realize I don't actually need this functionality right now. What I need to do is to convert a clojure string to a prolog string and then feed the prolog string into the shared library code.

At some point we should probably look into implementing term_string/2... but it is not this day!

---

Update 4

read_term_from_chars/3 🤦

[jjtolton]

Wait, this does work.

named_vars(VarNameIn, VarNameOut, Pred) :-
        Pred=(foo(VarNameIn, VarNameOut) :- VarNameIn #= VarNameOut + 1).

?- named_vars(X, Y, Pred).
%@    Pred = (foo(X,Y):-X#=Y+1).

Wait, lol. What?

[jjtolton]

The more I learn about Prolog, the more I learn how little I know about Prolog.

[hurufu]

I did something similar in one of my projects (https://github.com/hurufu/ffmpeg-planner/blob/master/fol.prolog) Don't bother reading full project, because currently ChatGPT is 10000 times better at what I wanted that project to be :)

But some parts are salvageable. I don't remember much detail, but if I recall correctly (and most probably I don't) the main idea was as follows:

1. Assume we work with term (foo(X, Y) :- Y #= X + 1) for simplicity.
2. Find all free variables using term_variables/2

   term_variables((foo(X,Y):-Y#=X+1), [X,Y]).

3. Apply constraint to them to be all different: dif(X, Y).
4. Use DCG to find a suitable name for them, and previous constraint will guarantee that you wouldn't have any name clash
5. That's all, now you have a term of this form (foo('?a', '?b') :- '?b' #= '?a' + 1) which is trivial to convert to lisp notation.

[hurufu]

You can just use numbervars/3 predicate and then rename atoms of form '$VAR(0)' to whatever suits your case.

[jjtolton]

Hmmm

   ?- numbervars(f(X), 0, End).
   %@    X = '$VAR'(0), End = 1.

How does this help with term_string/2 impl...? I'm not following :( But I would like to!

[jjtolton]

I did something similar in one of my projects (https://github.com/hurufu/ffmpeg-planner/blob/master/fol.prolog) Don't bother reading full project, because currently ChatGPT is 10000 times better at what I wanted that project to be :)

But some parts are salvageable. I don't remember much detail, but if I recall correctly (and most probably I don't) the main idea was as follows:

1. Assume we work with term (foo(X, Y) :- Y #= X + 1) for simplicity.
2. Find all free variables using term_variables/2

   term_variables((foo(X,Y):-Y#=X+1), [X,Y]).

3. Apply constraint to them to be all different: dif(X, Y).
4. Use DCG to find a suitable name for them, and previous constraint will guarantee that you wouldn't have any name clash
5. That's all, now you have a term of this form (foo('?a', '?b') :- '?b' #= '?a' + 1) which is trivial to convert to lisp notation.

I should clarify I'm trying to convert FROM lisp notation (although other way would be good, too).

[jjtolton]

Actually, now that I think about it... using strings will probably be fine. I think maybe my questions is just causing confusion. I realized the shared library code already does a great job of reading strings 🤔

[hurufu]

Ok, if you want from lisp notation (I think I've misread that point), you will need to create "holes" (fresh variables) for every atom of form '?a'. For example you can spawn fresh variables using functor/3 or (=..)/2.

[jjtolton]

read_term_from_chars/3

The mightiest of facepalms. Thanks @triska

[hurufu]

Wow, I didn't know about that. So many wheels reinvented :)