Proposed new syntax

[Gregory Ewing]

Steve D'Aprano wrote:

> from io import StringIO  # simulate reading from a file
> myfile = StringIO('Is this the room for an argument?')
> values = [myfile.read(1) for i in range(33)]
> print(''.join(values))

Which is a very contrived and longwinded way to write

    print(myfile.read(33))

and would be much better written that way.

Nobody is denying that it's *possible* to write comprehensions
that rely on order of evaluation. That doesn't mean it's a good
idea to do so.

> they also care
> about what it contains, and that the comprehension or generator expression
> iterates over its argument in a specific order.

I don't think they really care about that. What they actually
care about is that the resulting elements are in the same
*order* as the corresponding source elements. That's a
concept that doesn't inherently have anything to do with
time, so you can think about it without having to visualise
things happening sequentially.

Or at least you can as long as the comprehension doesn't
have anything like 'while' in it. If it does, then the
abstraction isn't just a bit leaky, it has a massive
iceberg-sized hole in the hull.

> [format(linenum) + line for (linenum, line) in enumerate(myfile)]
> 
> I think that most people would be disturbed if the returned list didn't match
> the order of lines in the file.

The order of the elements in the list, yes, but not the
order in time in which they were generated.

> If we write:
> 
> [process(a) for a in (1, 2, 3)]

then we get ridiculed for being a clueless noobie who
doesn't know how to use comprehensions properly. :-)

(Actually, this being c.l.p, we just get it gently pointed
out that we're uselessly building a list of Nones and
then throwing it away, so it would be much better to
write it as a for-statement instead. But the essence is
the same.)

-- 
Greg