PEP 343, second look

[Ron Adam]

After taking a break from following PEP 343 and it's associated PEPs, I 
wanted to look at it again because it still seemed a bit hard to get my 
mind around.

     http://www.python.org/peps/pep-0343.html


> A new statement is proposed with the syntax:
> 
>         with EXPR as VAR:
>             BLOCK
> 
>     Here, 'with' and 'as' are new keywords; EXPR is an arbitrary
>     expression (but not an expression-list) and VAR is a single
>     assignment target.

How is EXPR arbitrary?  Doesn't it need to be or return an object that 
the 'with' statement can use?  (a "with" object with an __enter__ and 
__exit__ method?)

And if so, what is the minimum 'with' class needed to create such an 
object?  It would need an __exit__ method, because there would be no 
point if it didn't have one.  Does it absolutely need an __enter__ 
method?  Are there any uses that might not require an __enter__?

Presuming __enter__ is always needed, would this be a minimum class that 
returns a 'with' object?

    class With(object):
        def __enter__(self):
            pass
        def __exit__(self):
            pass


A 'with-generator' object would need __enter__ and __exit__ methods, and 
a try-yield-finally generator. Is there a name for a 'with-generator' 
object?  (a witherator ?)

It's possible that a function may be used that returns an 
'with-generator' object and would be used in the same way that range() 
is used in 'for' statements.

     func with_gen(func, *args, **args):
         wg = WithGen()
         wg.gen = func(*arg, **args)
         return wg


Which would use a generic with-generator base class.

     class WithGen(object):
        def gen(self):         # Should this raise an error
            try:               # if it does't get over ridden?
                yield None
            finally:
                pass
        def __enter__(self):
            try:
                return self.gen.next()
            except StopIteration:
                raise RuntimeError("generator didn't yield")
        def __exit__(self, type, value, traceback):
            if type is None:
                try:
                    self.gen.next()
                except StopIteration:
                    print "file closed by with statement"
                    return
                else:
                    raise RuntimeError("generator didn't stop")
            else:
                try:
                    self.gen.throw(type, value, traceback)
                except (type, StopIteration):
                    return
                else:
                    raise RuntimeError("generator caught exception")


And used like this:

     def opening(filename, mode):
         f = open(filename, mode)
         try:
            yield f
         finally:
            f.close()

     with with_gen(opening, "testfile", "w") as f:
         f.write("test file")


This seems (to me) to be an easier to understand alternative to the 
decorator version.  The class could also be used as a base class for 
constructing other 'with' class's as well as the with_template decorator.

Will this work or am I missing something?  Any suggestions for a 
different (better) name for the with_gen function?

Regards,
Ron