Guido van Rossum wrote:
>> What was intended probably would be more closely related to constructing
>> a switch with BASICS gosub command.
>
> I understand now.
>
> But I have a question: if I write
>
> for i in range(10):
> switch S:
> case i: print 42
>
> (i.e. the switch is *inside* the for loop) does the switch get defined
> 10 times (with 10 different case values!) or not?
In this instance the switch would be redefined 10 times. The ending
switch would be:
switch S:
case 10: print 42
The static keyword could be used with this form as well to force define
time evaluation. (see last example.)
> I'm not sure I like the idea of using BASIC as a way to explain Python
> functionality... :-)
Yes, I agree! :-)
Fortunately, once (and if) it's defined (what ever it turns out to be)
Python examples can be used to explain Python. ;-)
>> Each case label expression would be evaluated when the switch block is
>> executed, ie... in order it appears in the program, but the code for
>> each case would be skipped until a (do choice in choices) line. Each
>> switch case block would not fall through but return to the next line
>> after the 'do' line by default.
>>
>> The whole thing could be put in a separate function or method if it's
>> desired to get the single function call form you suggested along with a
>> separate name space.
>>
>> def switcher(choice):
>> switcher roo:
>> 1: a = 42
>> 42: a = 1
>> else: raise ValueError
>>
>> do choice in switcher:
>> return a
>>
>> switcher(1) -> 42
>> switcher(42) -> 1
>> switcher(100) -> raises exception
>
> I'm still unclear on when you propose the case expressions to be
> evaluated. Each time the "switch" statement is encountered? That would
> be the most natural given the rest of your explanation. But then a
> switch inside a function that references globally defined constants
> would be re-evalulated each time the function is called; much of the
> discussion here is focused on trying to reduce the number of times the
> switch cases are evaluated to once per program invocation or once per
> function *definition*.
Each time the 'switch' statement is encountered for the above.
Allowing static to be used with this form could be an option to force
function define time evaluations of cases.
ONE = 1
FOURTYTWO = 42
def switcher(choice):
static switcher roo: # evaluate cases at function def time.
ONE: a = 42
FOURTYTWO: a = 1
else: raise ValueError
do choice in switcher:
return a
switcher(1) -> 42
switcher(42) -> 1
switcher(100) -> raises exception
That would give you both call time and def time evaluations for cases
with clear behavior for both (I think).
Also since the switch has a name, it might be possible to examine their
values with dir(switch_suite_name). That might help in debugging and
explaining the behavior in different situations.
The 'case' keyword could be left off in this form because the switch
body is always a suite. I find it more readable without it in the case
of simple literals or named values, and more readable with it for more
complex expressions.
I don't think I can clarify this further without getting over my head.
I probably am a bit already. I'm in the know enough to get myself in
trouble (at times) group. ;-)
Ron
_______________________________________________
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
