Gustavo Niemeyer wrote:
> Greetings,
>
>
>>Reasoning: The block statement resembles a "while" block in some ways in
>>that it is a conditional block that may be executed only once, or
>>possibly not at all (or many times). And the word "while" is also
>>descriptive of how a block is used.
>>
>> while VAR1 from EXPR1():
>> BLOCK
>
>
> This is an interesting propose, but for a different PEP.
Maybe someone who is more familiar with submitting a PEP could submit it
as a competing PEP to 340 then.
In the
> current propose VAR1 is not evaluated for truthness, and many of
> the usage examples doesn't even require it.
VAR1 isn't evaluated for truthfulness, but the expression as a whole is.
It just says, EXPR1 is a iterator, and VAR1 received a value from it.
Evaluating to a bool makes it consistent with the 'while' statement
usage and those checks are all-ready taking place in the block
statement. Here they are explicit instead of implicit which adds to the
readability. IMHO of course.
> This looks quite strange, for instance:
>
> while dummy from locking(myLock):
> # Do something
I thought of that, but I could get use to it. The dummy helps make it
readable although the value may not actually be used in the block. One
use with locks is to return a count of the current locks. Useful for
monitoring what the iterator is doing.
A shorter "while locking(myLock):" could be used, and the "dummy from"
be optional. In that case the returned None would be discarded.
while [NAME from] ITERATOR():
Or it could be made explicit with:
while None == locking(myLock):
Although I suppose this would look strange to some also. In this case,
an explicit test is being made of the returned VAR1. Testing for other
values could be possible.
> And also, this would require a break necessarily:
>
> while (foo, bar) from locking():
> # Pass
If the iterator is written without a loop in it, it will only execute
one yield, so the second time though it will end without returning a
value.
def locking():
try:
yield lock()
finally:
release lock()
This will execute once in an extended while.
def locking():
try:
while True:
yield new_lock()
finally:
release_all_locks()
This would need to be broken out of.
>>This will require a new keyword/operator 'from' to use in a 'from'
>>expression:
>
>
> 'from' is already a keyword, btw.
Oh, um... need more sleep. ;-)
So no new keywords would be needed in this example, just an alternate
use of an existing keyword. Replace the above with...
>>This will require *no* new keyword, the keyword/operator 'from' will
have a new use in an extended while expression:
Since I tend to put imports at the top of my programs and never see
'from' anywhere else, it didn't ring a bell.
Any reason why they both couldn't work?
Cheers, Ron_Adam
_______________________________________________
Python-Dev mailing list
Python-Dev@python.org
http://mail.python.org/mailman/listinfo/python-dev
Unsubscribe:
http://mail.python.org/mailman/options/python-dev/archive%40mail-archive.com
