[Python-3000] super(), class decorators, and PEP 3115
Guido van Rossum
guido at python.org
Tue May 1 00:54:04 CEST 2007
On 4/30/07, Phillip J. Eby <pje at telecommunity.com> wrote:
> At 12:17 PM 4/30/2007 -0700, Guido van Rossum wrote:
> >Assuming class decorators are added, can't you do all of this using a
> >custom metaclass?
> The only thing I need for the GF PEP is a way for a method decorator to get
> a callback after the class is created, so that overloading will work
> correctly in cases where overloaded methods are defined in a subclass.
I still don't understand why you can't tell the users "for this to
work, you must use my special magic super-duper metaclass defined
*here*". Surely a sufficiently advanced metaclass can pull of this
kind of magic in its __init__ method? If not a metaclass, then a
super-duper decorator. Or what am I missing?
> In essence, when you define an overloaded method inside a class body, you
> would like to be able to treat it as if it were defined with
> "self:__class__", where __class__ is the enclosing class. In practice,
> this means that the actual overloading has to wait until the class
> definition is finished.
> In Python 2.x, RuleDispatch implements this by temporary tinkering with
> __metaclass__, but if I understand correctly this would not be possible
> with PEP 3115. I didn't make this connection until I was fleshing out my
> PEP's explanation of how precedence works when you are overloading instance
> methods (as opposed to standalone functions).
Correct. As the word tinkering implies, you'll have to come up with a
> If PEP 3115 were changed to restore support for __metaclass__, I could
> continue to use that approach. Otherwise, some other sort of hook is required.
I'm -1 on augmenting PEP 3115 for this purpose.
> The class decorator thing isn't an issue for the GF PEP as such; it doesn't
> use them directly, only via the __metaclass__ hack. I just brought it up
> because I was looking for the class decorator PEP when I realized that the
> old way of doing them wouldn't be possible any more.
As long as someone's working on it (which I hear someone is), the
class decorator PEP is secure; the actualy discussion was closed
successfully weeks ago.
But I don't understand how a __metaclass__ hack can use a class decorator.
> >I'm not sure that your proposal for implementing an improved super has
> >anything over the currently most-favored proposal by Timothy Delaney.
> It's merely another use for the hook, that would save on having another
> special-purpose mechanism strictly for super(); I figured that having other
> uses for it (besides mine) would be a plus.
I'd leave that up to the folks currently discussing super.
--Guido van Rossum (home page: http://www.python.org/~guido/)
More information about the Python-3000