Naming help for a looping facility

["Linus Björnstam" <linus.internet@fastmail.se>]

Hello fellow guilers!

I have been writing the bastard child of foof-loop/chibi loop (https://mumble.net/~campbell/darcs/hack-foof-loop/foof-loop.txt) and racket's for loops. The current pre-beta can be found here: https://git.sr.ht/~bjoli/goof-loop/

I want to, just like the racket loops, provide simple forms, so that I instead of

(loop ((:for a (up-from 0 10)) (:acc acc (listing (* a a)))) => acc)

can write

(NAME ((:for a (up-from 0 10))) (* a a)).

My struggle is what I should name this. In racket it is for/list. I could of course call it loop/list, but that is inconsistent with the naming inherited from (chibi loop): listing. loop/listing becomes verbose (it's scheme after all) and is very clear what it does. But, as I already have a listing macro to be used within the loop facility, wouldn't (listing ((:for a (up-from 0 10)) ...) be a good name? Is it too magical?

I happen to think that it is elegant, but I don't know. It doesn't feel like the scheme way. I am pretty sure I want a special form for these things, as it allows for some optimization work. listing, as we all understand, has to reverse it's arguments, whereas a special form easily can rewrite itself to be a non-tail-recursive loop (which is faster than a reverse, yet without all the nasty sides of reverse!)

The options as of right now:

(loop/list ...)
Upsides:
  - pretty short
  - loop/list works differently from listing, even tthough the end result is the same. This signals that to some extent.
  -  If I am stealing from racket anyway...
Downsides:
  - not as clear as (loop/listing ...). To be honest, this is a pretty big one. If I _could_ I would make (loop (... ( ...(listing ...))) ...) work like the simple form, but that is not possible if we have other accumulating clauses.

(loop/listing ...)
Upsides:
  - The most clear
Downsides:
  - Verbose, which is what we want to avoid.

(listing ...)
Upsides:
  - We export fewer identifiers
  - Is already used as an accumulating clause
  - shortest
Downsides:
  - Too much magic?
  - One exported form does two related, but different things in different contexts?
  - (anding ...) makes sense, whereas (loop (... (:acc a (anding ...))) ...) does almost not at all.

I somewhat prefer the last one, but it feels icky. So, scheme sages of guile-user, what do you say?

Liebe Grüße
  Linus Björnstam