while (a=b()) ...

[Paul Boddie]

Greg Ewing wrote:
> 
> "Evan Simpson" <evan at tokenexchange.com> writes:
> | while 1:
> |   value = getValue()
> | and while value:
> |   process(value)

[...]

>   while:
>     line = f.readline()
>   gives line <> "":
>     frobulate(line)
> 
> Requires a new keyword... maybe in Python 2?

Of all the suggestions this is possibly the best one I have seen, although I am
still sitting on the fence in this debate. ;-) If anything new, in terms of
changes or additions to the language syntax, must come from this issue then I
would suggest that it fit these criteria:

1. It doesn't make scanning and reading of code harder. Thus I am somewhat
against any proposal for something like this:

   do:
     <do something>
   do <cond1>:
     <do something>
   do <cond2>:
     <do something>

   With long loops, and plenty of blank lines, it may be difficult to identify
single loops at a glance.

2. It doesn't permit "cool" tricks which make code unnecessarily hard to
   follow. A classic example of this would be (from C):

   while (*a++ = *b++);

   Once understood this might be seen as being "clever", but I am of the opinion
that code is there to be maintained in a convenient way rather than be some kind
of altar to a self-proclaimed "coding god".

3. It allows constructs which are intuitive, so that one is not constantly
having to remember that something works one way when one's intuition tells
oneself that it might work in another way. The first quoted example seems to
attempt to provide a split-up loop condition with a nod towards even more
general cases, as if we were doing something like this (in syntax which finally
finds a use for curly braces):

   while 1 {value = getValue()} and value:
     process(value)

   # Exploit this further.

   while 1 {value = getValue()} and value {otter = getAnimal(value)} and otter:
     process(otter)

   The second quoted example seems more specialised, but could appeal to one's
intuition more. In saying that "we are getting values from this source on every
iteration and will continue given this condition being true" it conveys a
simpler message, although the keywords might still need to be better chosen:

   using:                  # or with, having, <insert favourite name here>
     line = f.readline()
   while line:
     do_the_business(line)

   The first example I gave (point 1) doesn't appeal to me so much (but then I
only mentioned it so that I could criticise it). One could interpret this as
being a sequence of loops where the flow of execution starts at the top and
iteration is confined to the top loop until <cond1> is met, at which point the
next loop is entered and iteration is confined only to that block until <cond2>
is met. There certainly is room for ambiguity in the interpretation of this kind
of construct if one has only a passing familiarity with it.

Anyway, I feel that this discussion is not necessarily pointless because people
don't have a need for improvements in this area of Python, but rather because
people easily divide into the two main camps: those who just want to do "while a
= b" because they are comfortable with it (from C-style languages), and those
who don't find that acceptable at all.

Paul

P.S. Apologies for all of you who got to see this message twice: the first
version getting overly wrapped by the lovely Netscape Communicator, for which a
preview mode should have been implemented. This version should make the examples
a bit easier to follow.