Marc Battyani wrote:

...

Plans for 1.5:

• Move more code from the initially / loop prologue section

inside the let

...

binding initialization, which might cause some user code to

fail because of code movement

Please don't wreck that! It's the reason I initially started to use iterate. Those parts (prologue/epilog/var bindings) are under (and badly) specified in LOOP and implementations differ on this. So let's keep it in a sane way.

What I mean is that Iterate is inconsistent. Did you know that WITH clauses get completely placed inside the surrouding let, while FOR ... ON <list> gets set in the :initially section, while other (e.g. reducing ...) also get set inside LET?

I wanted to move as much as possible inside the surrouding LET. There's a *small* posibility that user code will break.

In fact, I expect none of the current tests to fails as a result of such a change.

...

For a farther future: move to another design for iteration

Do you already have some ideas on this ?

No. gclcvs (which passed most Iterate tests) reminded me of the other Iterate package featuring gathering. I'll look at that.

What really disturbs me with Iterate has a design weakness about referential transparency and inadvertent capture, e.g. (iter (with-some-other-macro (collect foo))) when with-some-other-macro itself expands to an iterate loop.

It similar to those cases when an implicit block would change the target of a return statement.

There's IMHO no way around that deficiency in Iterate.

LOOP OTOH is robust against that, since it knows no clauses nested inside normal Lisp forms.

Regards, Jörg.