[Python-Dev] Product iteration
Eric S. Raymond
Tue, 25 Jul 2000 15:28:32 -0400
Moshe Zadka <firstname.lastname@example.org>:
> A large part of the problem in list comprehensions (I think) is that we
> need to allow more then one "for" term, so we can iterate over the product
> of several lists. Why not solve that the same way we solved the parallel
> iteration problem, by using a function, called, say, "product".
> Then list comprehensions can limited to be (in pseudo formal grammar):
> '[' expr 'for' var 'in' seq [ 'if' pred ] ']'
> Such that "var" can be anything that can today be in a for loop, e.g.,
> (x, (y, z))
> Then we wouldn't have the irksome problem of how for's and if's intermix:
> the predicate at the end can be an and'ed sequence of predicates.
*KLANNGGG!!!* <-- the sound of the sacred two-by-four of enlightenment
belatedly whacking Eric upside the head
Dammit, I should have seen this sooner; the whole debate about parallel
loops and zip() was a flare-lit clue. Gentlemen, we've been going
entirely down the wrong path trying to express list comprehensions via
a syntax in imperative style. What they want to be is an applicative
sublanguage in functional style -- and mostly about data composition
rather than the expression of iteration per se.
zip() is part of this. Finding a way to handle conditionals ain't hard;
in fact, it's already in the language! The right way to say
[x**2 for x in range(1, 99) if isprime(x)]
is like this:
[x**2 for x in filter(isprime, range(1, 99)]
Look at the implications: there is no longer any need for special
syntax (or for python-dev debates over special syntax, or newbie
confusion over special syntax) on the right side of the for. We get
all the power of list comprehensions from one simple [for ... in ...]
construct exactly parallel to the for ... in that Python programmers
So instead of trying to fix list comprehensions with syntactic hacks,
we can extend it by having a properly rich and orthogonal set of
filter, zip, product, and lambda are good enough to cover anything the
presently proposed comprehension syntax can handle. But there's a
difference, because unfreezing and extending a syntax is a heckuva
lot harder than inventing new functional constructors.
If you notice that this looks a lot like LISP or F or Haskell, you win.
These languages got comprehensions right on the basis of a lot of
experience in depth. We can learn from their example.
<a href="http://www.tuxedo.org/~esr">Eric S. Raymond</a>
An armed society is a polite society. Manners are good when one
may have to back up his acts with his life.
-- Robert A. Heinlein, "Beyond This Horizon", 1942