[Python-checkins] python/nondist/peps pep-0343.txt, NONE, 1.1 pep-0000.txt, 1.305, 1.306

gvanrossum@users.sourceforge.net gvanrossum at users.sourceforge.net
Sat May 14 02:08:22 CEST 2005

Update of /cvsroot/python/python/nondist/peps
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv7951

Modified Files:
Added Files:
Log Message:
Add PEP 343: Anonymous Block Redux

--- NEW FILE: pep-0343.txt ---
PEP: 343
Title: Anonymous Block Redux
Version: $Revision: 1.1 $
Last-Modified: $Date: 2005/05/14 00:08:20 $
Author: Guido van Rossum
Status: Draft
Type: Standards Track
Content-Type: text/plain
Created: 13-May-2005


    After a lot of discussion about PEP 340 and alternatives, I've
    decided to withdraw PEP 340 and propose a slight variant on PEP

Motivation and Summary


Use Cases

    See the Examples section near the end.


    A new statement is proposed with the syntax

        do EXPR as VAR:

    Here, 'do' and 'as' are new keywords; EXPR is an arbitrary
    expression (but not an expression-list) and VAR is an arbitrary
    assignment target (which may be a comma-separated list).

    The "as VAR" part is optional.

    The choice of the 'do' keyword is provisional; an alternative
    under consideration is 'with'.

    A yield-statement is illegal inside BLOCK.  This is because the
    do-statement is translated into a try/finally statement, and yield
    is illegal in a try/finally statement.

    The translation of the above statement is:

        abc = EXPR
            VAR = abc.__enter__()
            abc.__exit__(*sys.exc_info())  # XXX See below

    If the "as VAR" part of the syntax is omitted, the "VAR =" part of
    the translation is omitted (but abc.__enter__() is still called).

    The call to abc.__exit__() is only approximated as written.  The
    actual calling convention is: If the finally-suite was reached
    through normal completion of BLOCK or through a "non-local goto"
    (a break, continue or return statement in BLOCK), abc.__exit__()
    is called without arguments (or perhaps with three None
    arguments).  If the finally-suite was reached through an exception
    raised in BLOCK, abc.__exit__() is called with three arguments
    representing the exception type, value, and traceback.

Optional Generator Decorator

    It is possible to write a decorator that makes it possible to use
    a generator that yields exactly once to control a do-statement.
    Here's a sketch of such a decorator:

	class Wrapper(object):
	   def __init__(self, gen):
	       self.gen = gen
	       self.state = "initial"
	   def __enter__(self):
	       assert self.state == "initial"
	       self.state = "entered"
		   return self.gen.next()
	       except StopIteration:
		   self.state = "error"
		   raise RuntimeError("template generator didn't yield")
	   def __exit__(self, *args):
	       assert self.state == "entered"
	       self.state = "exited"
	       except StopIteration:
		   self.state = "error"
		   raise RuntimeError("template generator didn't stop")

	def do_template(func):
	   def helper(*args, **kwds):
	       return Wrapper(func(*args, **kwds))
	   return helper

    This decorator could be used as follows:

	def opening(filename):
	   f = open(filename) # IOError here is untouched by Wrapper
	   yield f
	   f.close() # Ditto for errors here (however unlikely)

    A robust implementation of such a decorator should be made part of
    the standard library.


    Several of these examples contain "yield None".  If PEP 342 is
    accepted, these can be changed to just "yield".

    1. A template for ensuring that a lock, acquired at the start of a
       block, is released when the block is left:

        def locking(lock):
            yield None

       Used as follows:

        do locking(myLock):
            # Code here executes with myLock held.  The lock is
            # guaranteed to be released when the block is left (even
            # if via return or by an uncaught exception).

    2. A template for opening a file that ensures the file is closed
       when the block is left:

        def opening(filename, mode="r"):
            f = open(filename, mode)
            yield f

       Used as follows:

        do opening("/etc/passwd") as f:
            for line in f:
                print line.rstrip()

    3. A template for committing or rolling back a database
       transaction; this is written as a class rather than as a
       decorator since it requires access to the exception information:

        class transactional:
            def __init__(self, db):
	        self.db = db
            def __enter__(self):
	    def __exit__(self, *args):
	        if args and args[0] is not None:

    4. Example 1 rewritten without a generator:

        class locking:
           def __init__(self, lock):
               self.lock = lock
           def __enter__(self):
           def __exit__(self, *args):

       (This example is easily modified to implement the other
       examples; it shows how much simpler generators are for the same

    5. Redirect stdout temporarily:

        def redirecting_stdout(new_stdout):
            save_stdout = sys.stdout
                sys.stdout = new_stdout
                yield None
                sys.stdout = save_stdout

       Used as follows:

        do opening(filename, "w") as f:
            do redirecting_stdout(f):
                print "Hello world"

    6. A variant on opening() that also returns an error condition:

        def opening_w_error(filename, mode="r"):
                f = open(filename, mode)
            except IOError, err:
                yield None, err
	        yield f, None

       Used as follows:

        do opening_w_error("/etc/passwd", "a") as f, err:
            if err:
                print "IOError:", err

    7. Another useful example would be an operation that blocks
       signals.  The use could be like this:

        import signal

        do signal.blocking():
            # code executed without worrying about signals

       An optional argument might be a list of signals to be blocked;
       by default all signals are blocked.  The implementation is left
       as an exercise to the reader.


    This document has been placed in the public domain.

Index: pep-0000.txt
RCS file: /cvsroot/python/python/nondist/peps/pep-0000.txt,v
retrieving revision 1.305
retrieving revision 1.306
diff -u -d -r1.305 -r1.306
--- pep-0000.txt	11 May 2005 21:58:13 -0000	1.305
+++ pep-0000.txt	14 May 2005 00:08:19 -0000	1.306
@@ -120,6 +120,7 @@
  S   340  Anonymous Block Statements                   GvR
  S   341  Unifying try-except and try-finally          Birkenfeld
  S   342  Enhanced Iterators                           GvR
+ S   343  Anonymous Block Redux                        GvR
  S   754  IEEE 754 Floating Point Special Values       Warnes
  Finished PEPs (done, implemented in CVS)
@@ -380,6 +381,7 @@
  S   340  Anonymous Block Statements                   GvR
  S   341  Unifying try-except and try-finally          Birkenfeld
  S   342  Enhanced Iterators                           GvR
+ S   343  Anonymous Block Redux                        GvR
  SR  666  Reject Foolish Indentation                   Creighton
  S   754  IEEE 754 Floating Point Special Values       Warnes
  I  3000  Python 3.0 Plans                             Kuchling, Cannon

More information about the Python-checkins mailing list