Proposed addition: cond_t/2

[jjtolton]

In lisp, cond is used the way if/elseif is used in other languages.

(cond
   (= 2 4) [6 8]
   (= "who" "do" "we") "appreciate"
   (= prolog awesome) "Yay!"
) 
;;=> "Yay!"

The following modification to reif, an addition of cond_t/2 would allow for similar syntax:

cond_t([], false).
cond_t([Goals,Effects|Conds], Truth) :-
        if_(Goals,
            (   Effects, Truth=true ),
            cond_t(Conds, Truth)
           ).

Such as:

?- cond_t([(1=A, A=B), A=1,
           A=B, B=2],
          Truth).
%@    A = 1, B = 1, Truth = true
%@ ;  A = 1, Truth = false, dif:dif(1,B)
%@ ;  A = 2, B = 2, Truth = true
%@ ;  Truth = false, dif:dif(A,B), dif:dif(1,A).

?- cond_t([1=2, true, 1=5, true], Truth).
%@    Truth = false.

?- cond_t([(1=A, A=B), (X #= 1 + 2, C=4),
           (   B=3, B+2 #= X ), X=5,
           1=1, X=5],
          Truth).
%@    A = 1, B = 1, X = 3, C = 4, Truth = true
%@ ;  A = 1, B = 3, X = 5, Truth = true
%@ ;  A = 1, X = 5, Truth = true, dif:dif(B,3), dif:dif(1,B)
%@ ;  B = 3, X = 5, Truth = true, dif:dif(1,A)
%@ ;  X = 5, Truth = true, dif:dif(1,A), dif:dif(B,3).

otherwise I just end up finding myself doing nested if_s, which is a bummer.

Any thoughts?

[UWN]

Putting goals into lists is not a good choice since this cannot be covered/fully typed with meta-predicate declarations.

[jjtolton]

This would be a possibility albeit I am not very much convinced. Having this flat argument list with different meanings all over is a recipe for errors. Look at the way all the (^)/2 are defined and used in library(lambda). And just to reiterate to your original Lisp example: Even Lisp does not have a fully flattened out cond. It requires more parentheses as you did.

In other Prolog code, I see "if/elif"-style conditionals handled using -> with (;)/2. It sounds like you are suggesting the use of something like (^)/2 for partitioning the disjunctive conditional branches would be preferable to a flat argument list?

[UWN]

Yes, but not sure how.

[jjtolton]

Certain predicates take lists of options, such as http_open/3.

So, something like

?- cond([branch(GoalA_1, ThenA_0),
         branch(GoalB_1, ThenB_0)]).

of course, I also rather like the lambda syntax. This is the closest thing I can think of:

( GoalA_1 ? ThenA_0 
: GoalB_1 ? ThenB_0 
: Else0
).

might be an interesting syntax. : and ? is used as a ternary operator in several other languages. I'm sure ?/2 is not a greatest functor name but I haven't thought of a good symbolic name yet.

[UWN]

Lists of options are not lists of goals. One problem with the ISO if-then-else-if-then-else... construct is that it makes (;)/2 defaulty (default+faulty) which is better to be avoided. In any case I'd avoid single character operators, as they might interfere with normal uses. Like X = a is valid syntax, but if a is declared as an operator it is no longer valid.

[jjtolton]

An example of something that meets all the constraints (although not necessarily great names) would be something like this?

( GoalA_1 ?? ThenA_0 
:: GoalB_1 ?? ThenB_0 
:: Else0
).

(how it is that I would accomplish this syntax is another thing entirely...)

If I understand your comment correctly, this would not impact (;)/2, but (::)/2 would be defaulty? Hmm. That's a tricky one, I'll have to think about that.

[jjtolton]

I actually like this version better:

cond_t([], false).
cond_t([Goals,Effects|Conds], Truth) :-
        if_(Goals,
            (   Effects, Truth=true
            ;   cond_t(Conds, Truth) % ** allows for all possible true goals
            ),
            cond_t(Conds, Truth)
           ).

Edit: @UWN 's teaching me a thing or two about Prolog API 😁

[hurufu]

I think you can already do it using foldl/5:

cond(Goals, Effects, Default) :-
    foldl(\If^Then^Else^if_(If,Then,Else)^true, Goals, Effects, Default, Cond_0), Cond_0.

And then query it like this:

?- cond([X=1,X=2], [Y=a,Y=b], Y=c).
   X = 2, Y = b
;  X = 1, Y = a
;  Y = c, dif:dif(X,1), dif:dif(X,2). 

[UWN]

Nothing prevents anyone to use their own definition like p_t/2.

[hurufu]

Actually I guess, I came-up with a solution:

cond(Goals, Effects, Default, Cond_0) :-
    foldl(\If^Then^Else^if_(If,Then,Else)^true, Goals, Effects, Default, Cond_0).

With this approach cond/4 isn't a meta-predicate anymore, so even if it is hidden inside a module it doesn't matter, because the burden of calling if_/3 with all the goals lies on a caller, that means that everything what was visible to the caller will be automatically visible inside Cond_0.

[UWN]

... everything what was visible to the caller will be automatically visible inside Cond_0.

Goals is a simple list, so the goals inside, be they partial/incomplete or not, need to have the relevant module as the innermost prefix-structure (:)/2

[hurufu]

If called inside a user context (ie they all are callable as user:my_predicate(...)), then it should work ok, I guess. One just need to make sure that every predicate is available in user. For example:

:- use_module(reif_extensions). % Let's say it contains `p_t/2` predicate
:- use_module(cond). % It contains cond/4
:- use_module(foo).  % It contains foo/1

test(X,Y) :-
    cond([p_t(X)], [foo(Y)], Y=0, Cond_0),
    call(Cond_0).

The following query will succeed (I actually didn't test, but it should):

?- test(X,Y).

If we want to call it in another context then we can use my_module:call(Cond_0). But you are correct that if goals in Goals come all from different modules then yes, every goal should be explicitly qualified with (:)/2. I don't have a solution for that.

UPDT: I didn't run this code, I hope it works ;)

[UWN]

One just need to make sure that every predicate is available in user.

So, no modules.

[jjtolton]

I'm honestly astonished this works. Too good to be true?

:- use_module(library(reif)).

:- op(1100, xfy, ::).
:- op(1050, xfy, ??).

??(A,B) :- if_(A, B, false).
??(A,B,T) :-
        if_(A, 
            (   B -> T=true
            ;   T=false
            ),
            T=false
           ).

::(A,B) :- (A;B).



?- (  X=1
   ?? Y=a
   :: X=2
   ?? Y=b
   :: X=3
   ?? Y=c
   :: X=4,Y=d
   ).
%@    X = 1, Y = a
%@ ;  X = 2, Y = b
%@ ;  X = 3, Y = c
%@ ;  X = 4, Y = d.


?- (  X=1, Y=2
   ?? Z=a
   :: X=3, Y=5
   ?? Z=b
   :: X=6, Y=7
   ?? Z=c
   :: format("hey", []), nl, X=9, Y=11, Z=d
   ).
%@    X = 1, Y = 2, Z = a
%@ ;  X = 3, Y = 5, Z = b
%@ ;  X = 6, Y = 7, Z = c
%@ ;  hey
%@ X = 9, Y = 11, Z = d.


?- X=1 ?? Y=2.
%@    X = 1, Y = 2
%@ ;  false.

?- X=1 ?? Y=2 :: Y=3.
%@    X = 1, Y = 2
%@ ;  Y = 3.


?- (  X=1
   ?? false, Z=a
   :: X=2
   ?? Z=b
   :: X=3
   ?? Z=c
   :: format("hey", []), nl
   ).
%@    X = 2, Z = b
%@ ;  X = 3, Z = c
%@ ;  hey
%@ true.

?- (  X=1
   ?? Z=a
   :: X=2
   ?? Z=b
   ).
%@    X = 1, Z = a
%@ ;  X = 2, Z = b
%@ ;  false.

[hurufu]

o.pl:

:- module(o, [
    op(1100, xfy, ::),
    op(1050, xfy, ??),
    (::)/2,
    (??)/2,
    (??)/3
]).
:- use_module(library(reif)).

??(A,B) :- if_(A, B, false).
??(A,B,T) :-
        if_(A, 
            (   B -> T=true
            ;   T=false
            ),
            T=false
           ).

::(A,B) :- (A;B).

m.pl:

:- module(m, [foo_t/2]).
:- use_module(library(reif)).

foo_t(X, T) :-
    if_(X=foo, T=true, T=false).

u.pl:

:- use_module(o).
:- use_module(m).

t(Y) :- foo_t(_) ?? Y = 1 :: Y = 2.

The following query fails:

?- t(Y).
   error(existence_error(procedure,foo_t/2),foo_t/2).

[triska]

I think the problem should also be reproducible with only 2 files to make it is easier to understand.

[jjtolton]

Hmm.

%@ error(existence_error(procedure,foo_t/2),foo_t/2). is a somewhat inscrutable error.

Would anyone care to explain the mechanism? It seems like the lexical scope is not being tracked.

[triska]

The specified goal needs to be module-qualified. You can manually specify the required module (foomod:...) in the call, or add a meta_predicate/1 directive to the predicates (in library(cond)) to automatically specify the module in which the call is made. The meta_predicate/1 directive informs the compiler about which arguments are goals and therefore need to be module-qualified.

[jjtolton]

Huzzah!!! Forked is unforked!!! Amazing!! 😍

So that's what meta_predicate/1 does. This whole time I just thought it was optional type hinting or something.