I wrote:
> One idea is that we could do something like
> foreach_variant(identifier, list_value)
> {
> type *v = (type *) lfirst_variant(identifier);
> ...
> }
> where the "identifier" isn't actually a variable name but just something
> we use to construct the ForEachState variable's name. (The only reason
> we need it is to avoid confusion in cases with nested foreach's.)
On second thought, there seems no strong reason why you should need
to fetch the current value of a foreach-ish loop that's not the most
closely nested one. So forget the dummy identifier, and consider
this straw-man proposal:
#define aforeach(list_value) ...
(I'm thinking "anonymous foreach", but bikeshedding welcome.) This
is just like the current version of foreach(), except it uses a
fixed name for the ForEachState variable and doesn't attempt to
assign to a "cell" variable.
#define aforeach_current() ...
Retrieves the current value of the most-closely-nested aforeach
loop, based on knowing the fixed name of aforeach's loop variable.
This replaces "lfirst(lc)", and we'd also need aforeach_current_int()
and so on for the other variants of lfirst().
So usage would look like, say,
aforeach(my_list)
{
type *my_value = (type *) aforeach_current();
...
}
We'd also want aforeach_delete_current() and aforeach_current_index(),
to provide functionality equivalent to foreach_delete_current() and
foreach_current_index().
These names are a bit long, and maybe we should try to make them
shorter, but more shortness might also mean less clarity.
BTW, I think we could make equivalent macros in the old regime,
which would be a good thing because then it would be possible to
back-patch code using this notation.
Thoughts?
regards, tom lane
