[Python-Dev] Extended Function syntax

[Guido van Rossum]

[Samuele]
> yes, real-world examples would be good.

synchronized() is definitely a real-world example -- writing
try/finally for locks is a pain for all threaded code.

Another, related example would be something that blocks all signals
(or at least SIGINT) during a certain code block.

I imagine that there are quite a few examples that basically wrap a
code block in something that does some preparation and some cleanup.

These require that the cleanup action is done even if an exception
occurred in the block, and this can't be done with the "for loop" hack
proposed by Armin (unless you rely on __del__, which would be a no-no
for Jython).

'do' or 'with' should be up to this task.

I'm now wondering if there aren't really only two interesting cases,
none of which require saving the thunk and calling it later:

- synchronized-like, where the block should connect to its environment

- property-like, where the block should introduce a new scope, and the
  caller should be able to inspect or control that scope's namespace

All cases where something is saved to be called later can be done
by using the extended 'def' syntax (def f(...) [something]: ...).

I think that for synchronized-like cases, even if it is known at
compile time that it is to be part of the surrounding scope, the code
generated will still need to use nested-scope-cells, since it will be
invoked on a different stack frame: the "thunk processor" pushes its
own frame on the stack, and I think you can't have something that
executes in a frame that's not the topmost frame.  (Or can you?  I
don't know exactly what generators can get away with.)

--Guido van Rossum (home page: http://www.python.org/~guido/)