Re: Naming help for a looping facility

[Linus Björnstam]

On Sat, 6 Mar 2021, at 17:58, Zelphir Kaltstahl wrote:
> Hello Linus!
> 
> Not sure my idea for naming is any good: Perhaps you could use the word
> "iteration" or "iter" in combination with something else.

I don't think I will change the loop name. What I am interested in is the 
feedback for what to call the simpler forms. Should it be loop/list, 
loop/listing or simply (listing ...). I think the two latter are preferrable.

> 
> I have a bit of difficulty understanding how these forms work. The 
> readme could
> perhaps be better, if you showed the output as well as describing it, 
> which you
> already do and show multiple examples per form, varying the arguments. 
> For example:
> 
> ~~~~
> (define lst '((1 2) dud (3 4) (5 6)))
> (loop ((:for a (in-list lst))
>        (:when (pair? a))
>        (:for b (in-list a))
>        (:acc acc (summing b)))
>   => acc)
> ~~~~
> 
> What happens, if one leaves the :when away? Is it strictly necessary, when we
> already use in-list, telling the machine, that we are processing a list? What
> changes, when we put :subloop in there? I am guessing, that it is the 
> difference
> between nested looping and not nested.
> 
> In the example with :subloop, you have shown the output.
> 
> If comparing to Racket's for-loop variants, I could imagine, that it could
> improve understanding, if you put the Racket expression there and then show 
> how
> to do the same with the forms you are showing.

The documentation (in documentation/doc.html) is probably what you want to look 
at. That one explains it. When that one is finished, I  will revamp the readme 
to point to a hosted version of it.

But alas, you are correct: the readme is awful. I need to rewrite it. Regarding 
your comment about :when: every non-binding clause (:when, :break, :unless, 
:final, and :subloop) breaks out a new subloop. I do write about the results in 
the text following the code blocks - which I should also change. 


> 
> Would your implementation be portable between various Schemes? That would be
> great! One problem I had when migrating my decision tree implementation from
> Racket to GNU Guile was, that I had been using Racket's special for-loop forms
> and that I had to translate those back into named let or others, to get it
> running on GNU Guile. If one could simply load your library in any Scheme that
> fulfills some known and specified set of conditions, one would not need to 
> worry
> about portability of the code as much.

This is indeed portable. The meat of the loop is written in syntax-rules with 
one 10-line syntax-case macro (and some auxiliary procedures). If you want 
racket's for loops I do have an implementation of them for guile somewhere 
online, however this macro can do more things and will be strictly more 
powerful than racket's for loops when it is completely done. It is already more 
powerful, except for some fancy things they can do with their sequence api.

Anyway, if you want to port it to another scheme, you will have to rewrite 
about 70 lines in goof.scm. The files goof-impl.scm and goof/*.scm are all 
portable. What you DO need is a pattern matching macro (I use alex's match.scm).