(This entry originated as a post on the EiffelStudio user group mailing list.)
Here are a couple of actual examples of the new loop variants discussed in the blog entry immediately preceding this one. They came out of my current work; I started updating a program to take advantage of the new facility.
As a typical example, I replaced
eht: HASH_TABLE [EXPRESSION, EXPRESSION]
eht := item (e)
across item (e) as eht loop Result.extend (eht.key) end
which also gets rid of the local variable declaration. The second form is syntactic sugar for the first, but I find it justified.
Another case, involving nested loops:
oht := other.item_for_iteration
e := other.key_for_iteration
put (e, oht.item_for_iteration)
across other as o loop
across o.item as oht loop put (o.key, oht.item) end
here getting rid of two local variable declarations (although I might for efficiency reintroduce the variable e to compute o.key just once).
It is important to note that these are not your grandmother’s typical loops: they iterate on complex data structures, specifically hash tables where the keys are lists and the items are themselves hash tables, with lists as both items and keys.
The mechanism is applicable to all the relevant data structures in EiffelBase (in other words, no need for the programmer to modify anything, just apply the across loop to any such structure), and can easily extended to any new structure that one wishes to define. In the short term at least, I still plan in my introductory teaching to show the explicit variants first, as it is important for beginners to understand how a loop works. (My hunch based on previous cases is that after a while we will feel comfortable introducing the abstract variants from the start, but it takes some time to learn how to do it right.)