in search of a nicer super ...

[Michele Simionato]

Here is an idea for a nicer syntax in cooperative method calls,
which is not based on Guido's "autosuper" example. This is just a 
hack, waiting for a nicer "super" built-in ...

Here is example of usage:

from cooperative import Cooperative

class B(Cooperative):
    def print_(self):
        print "B",

class C(B):
    def print_(self, super):
        super.print_() # shortcut for super(C,self).print_()
        print "C",

class D(C):
    def print_(self, super):
        super.print_() # shortcut for super(D,self).print_()
        print "D",

D().print_() # prints BCD

Let me call "cooperative methods" methods with a second argument 
called "super": then super.method(*args, **kw) acts as a shortcut 
for super(cls,self).method(*args, **kw). This avoids the redundant
repetition of the class in the super object, a thing I always loathed :)

Here is the "cooperative" module:

$ cat cooperative.py
import inspect

def second_arg(func):
    args = inspect.getargspec(func)[0]
    if len(args) >= 2: return args[1]

class _Cooperative(type):
    def __init__(cls,name,bases,dic):
        for n,func in dic.iteritems():
            if inspect.isfunction(func) and second_arg(func) == "super":
                setattr(cls, n, cls.wrap(func))
    def wrap(cls, func):
        return lambda self, *args, **kw : \
               func(self, super(cls, self), *args, **kw)

class Cooperative:
    __metaclass__ = _Cooperative

I could make it to work for staticmethods and classmethods, but
I didn't bothered since I wanted to keep the cooperative module
under the twenty lines.

Just my 0.02c,


                          Michele Simionato