y u no terminate??

[jjtolton]

Three examples I have stumbled into back to back while researching I/O methods for Scryer Prolog. In each example, the most general query terminates continues to generate but doesn't infinitely backtrack with no output, and supplying the first argument terminates, but in all 3 cases, specifying the 2nd argument while keeping the first argument general immediately gets the correct result but then (upon ;) continues backtracking and never terminates.

The only thing I can think of is that the semicontext is pushing something onto the front of the list, which is causing the "empty list" termination rule to never happen. But that's purely speculation on my part, I haven't been able to conclusively come up with a reason.

The following examples borrow heavily from @triska 's work on dcgs.

numthings(Things, Num) :-
        phrase(numthings_(nonterminal(Things)), [0], [Num]).

numthings_(nonterminal([])) --> [].
numthings_(terminal(X)), [N] --> [N0], { N #= N0 + 1 }.

numthings_(nonterminal([H|T])) -->
        numthings_(terminal(H)),
        numthings_(nonterminal(T)).

?- numthings(Things, N).
%@    Things = [], N = 0
%@ ;  Things = [_A], N = 1
%@ ;  Things = [_A,_B], N = 2
%@ ;  Things = [_A,_B,_C], N = 3
%@ ;  Things = [_A,_B,_C,_D], N = 4
%@ ;  ... .

?- numthings("hey", N).
%@    N = 3
%@ ;  false.

?- numthings(Things, 5).
%@    Things = [_A,_B,_C,_D,_E]
%@ ;  y u no terminate??

strings2output([]) --> [].
strings2output(row(Row)), [Output] --> [Output0], { phrase(format_("~s\n~s", [Output0, Row]), Output) }.
strings2output([Row|Rows]) -->
        strings2output(row(Row)),
        strings2output(Rows).

strings2lines(Strings, Output) :-
        phrase(strings2output(Strings), [""], [Output]).
        
?- strings2lines(["hey", "there", "sailor"], Output).
%@    Output = "\nhey\nthere\nsailor".


?- strings2lines(Input, Output).
%@    Input = [], Output = []
%@ ;  Input = row([]), Output = "\n"
%@ ;  Input = row([_A]), Output = ['\n',_A]
%@ ;  Input = row([_A,_B]), Output = ['\n',_A,_B]
%@ ;  Input = row([_A,_B,_C]), Output = ['\n',_A,_B,_C]
%@ ;  ... .

?- strings2lines(Input, "\nhey\nthere\nsailor").
%@    Input = row("hey\nthere\nsailor")
%@ ;     y u no terminate?

num_leaves(Tree, N) :-
        phrase(num_leaves_(Tree), [0], [N]).

num_leaves_(nil), [N] --> [N0], { N #= N0 + 1 }.
num_leaves_(node(_,Left,Right)) -->
        num_leaves_(Left),
        num_leaves_(Right).


?- num_leaves(node(a,node(b,nil,nil),
                     node(c,nil,
                            node(d,nil,nil))), N).
%@    N = 5.

?- num_leaves(T, N).
%@    T = nil, N = 1
%@ ;  T = node(_A,nil,nil), N = 2
%@ ;  T = node(_A,nil,node(_B,nil,nil)), N = 3
%@ ;  T = node(_A,nil,node(_B,nil,node(_C,nil,nil))), N = 4
%@ ;  T = node(_A,nil,node(_B,nil,node(_C,nil,node(_D,nil,nil)))), N = 5
%@ ;  ... .

?- num_leaves(T, 3).
%@    T = node(_A,nil,node(_B,nil,nil))
%@ ;  y u no terminate?

I can't figure out why they don't terminate!

[hurufu]

This is very strange construction phrase(predicate(List), [0], [End]), normally you want your List to be the second argument of phrase and you use 3rd argument only if you want partial match (and only partial match): phrase(predicate(0, End), List). Do you want just to practice semicontext notation or you have a particular goal in mind?

[hurufu]

First example doesn't terminate because you don't have guards for situation when your counter grows larger then Num

[jjtolton]

Yes indeed! I stole the example from @triska 's section on Implicitly passing states around.

Ultimately what I am working towards is a declarative equivalent of:

outfile = open('/tmp/foo.txt', 'a')
for line in lines:
    print(line, file=outfile)

The big picture idea being, "loop" over a series of "rows", transform them somehow, and append them to a file. This is starting to work on "loop" and "transform".

I imagine foldl is probably an even better tool here, I'm open to suggestions. But I'm also just really curious why these aren't terminating!

[jjtolton]

First example doesn't terminate because you don't have guards for situation when your counter grows larger then Num

You are probably right, but I don't see how yet.

This is the exanded non-dcg code:

num_leaves(Tree, N) :-
        num_leaves_(Tree, 0, N).

num_leaves_(nil, N0, N) :- N #= N0 + 1.
num_leaves_(node(_,Left,Right), N0, N) :-
        num_leaves_(Left, N0, N1),
        num_leaves_(Right, N1, N).

?- num_leaves(Tree, 3).

you're saying there should be guards in there somehow?

[hurufu]

This variant of your first example terminates:

numthings(Things, Num) :-
        phrase(numthings_(Num, nonterminal(Things)), [0], [Num]).

numthings_(_, nonterminal([])) --> [].
numthings_(Max, terminal(_)), [N] --> [N0], { N0 #=< Max, N #= N0 + 1 }.

numthings_(Max, nonterminal([H|T])) -->
        numthings_(Max, terminal(H)),
        numthings_(Max, nonterminal(T)).

UPDT: I pasted wrong chunk of text

[hurufu]

I think your question about num_leaves/2 was already answered: #2483 (comment). And for strings2lines/2 (I hope I understood what you were trying to achieve correctly) you don't even need DCG , which maybe is less elegant, but at least trivially simple to understand which is a good thing:

:- use_module(library(lists)).

%% strings_text(Strings, Text).
% `Text` is a concatenation of all `Strings` each prefixed with new line character
strings_text([], []).
strings_text([H|T], R) :-
    L = ['\n'|H],
    append(L, Text, R),
    strings_text(T, Text).

[jjtolton]

I will examine these shortly to see if I can understand your technique!

[jjtolton]

Very cool!! I did not know you could use append to describe concatenation!! I'm learning a lot of things from your responses, @hurufu !

[hurufu]

Thanks, one more observation: usually generous use of ´append/3´ is considered a code smell and if you find yourself writting a lot of them then it is better to use DCGs.