At 03:20 PM 10/17/03 -0500, Skip Montanaro wrote:
* functions * unbound methods * bound methods * generator functions * iterators (currently invisible via syntax, but created by calling a generator function?) * instances magically callable via __call__
The last item on the list encompasses at least the first three. But you also left out __init__ and __new__, which are really ClassType.__call__ or type.__call__, though. :) To me (and the interpreter, actually), there's just tp_call, tp_iter, and tp_iternext (or whatever their actual names are). Callability, iterability, and iterator-next. Many kinds of objects may have these aspects, just as many kinds of objects may be addable with '+'. Of the things you mention, however, most don't actually have different syntax for creating them, and some are even the same object type (e.g. unbound and bound methods). And the syntax for *using* them is always uniform: () always calls an object, for ... in ... creates an iterator from an iterable, .next() goes to the next item.
and now this new (rather limited) syntax for creating iterators.
Actually, as now being discussed, list comprehensions would be a special case of an iterator expression.
I am beginning to find it all a bit confusing and unsettling.
Ironically, with iterator comprehension in place, a list comprehension would now look like a list containing an iterator, which I agree might be confusing. Too bad we didn't do iterator comps first, or list(itercomp) would be the idiomatic way to make a listcomp. That's really the only confusing bit I see about itercomps... that you have to be careful where you put your parentheses, in order to make your intentions clear in some contexts. However, that's true for many kinds of expressions even now.