[Python-Dev] Re: anonymous blocks

[Luis P Caamano]

On 4/29/05, python-dev-request at python.org <python-dev-request at python.org> wrote:
> 
> Message: 2
> Date: Thu, 28 Apr 2005 21:56:42 -0600
> From: Shane Hathaway <shane at hathawaymix.org>
> Subject: Re: [Python-Dev] Re: anonymous blocks
> To: guido at python.org
> Cc: Ka-Ping Yee <python-dev at zesty.ca>,  Python Developers List
>        <python-dev at python.org>
> Message-ID: <4271B07A.4010501 at hathawaymix.org>
> Content-Type: text/plain; charset=ISO-8859-1
> 
> 
> I think this concept can be explained clearly.  I'd like to try
> explaining PEP 340 to someone new to Python but not new to programming.
> I'll use the term "block iterator" to refer to the new type of
> iterator.  This is according to my limited understanding.
> 
> "Good programmers move commonly used code into reusable functions.
> Sometimes, however, patterns arise in the structure of the functions
> rather than the actual sequence of statements.  For example, many
> functions acquire a lock, execute some code specific to that function,
> and unconditionally release the lock.  Repeating the locking code in
> every function that uses it is error prone and makes refactoring difficult.
> 
> "Block statements provide a mechanism for encapsulating patterns of
> structure.  Code inside the block statement runs under the control of an
> object called a block iterator.  Simple block iterators execute code
> before and after the code inside the block statement.  Block iterators
> also have the opportunity to execute the controlled code more than once
> (or not at all), catch exceptions, or receive data from the body of the
> block statement.
> 
> "A convenient way to write block iterators is to write a generator.  A
> generator looks a lot like a Python function, but instead of returning a
> value immediately, generators pause their execution at "yield"
> statements.  When a generator is used as a block iterator, the yield
> statement tells the Python interpreter to suspend the block iterator,
> execute the block statement body, and resume the block iterator when the
> body has executed.
> 
> "The Python interpreter behaves as follows when it encounters a block
> statement based on a generator.  First, the interpreter instantiates the
> generator and begins executing it.  The generator does setup work
> appropriate to the pattern it encapsulates, such as acquiring a lock,
> opening a file, starting a database transaction, or starting a loop.
> Then the generator yields execution to the body of the block statement
> using a yield statement.  When the block statement body completes,
> raises an uncaught exception, or sends data back to the generator using
> a continue statement, the generator resumes.  At this point, the
> generator can either clean up and stop or yield again, causing the block
> statement body to execute again.  When the generator finishes, the
> interpreter leaves the block statement."
> 
> Is it understandable so far?
> 

I've been skipping most of the anonymous block discussion and thus,
I only had a very vague idea of what it was about until I read this
explanation.

Yes, it is understandable -- assuming it's correct :-)

Mind you though, I'm not new to python and I've been writing system
software for 20+ years.

-- 
Luis P Caamano
Atlanta, GA USA