Title: Changing return value for mutating list methods (meta programming)
Submitter: Stephan Diehl (other recipes)
Last Updated: 2003/09/13
Version no: 1.2
Category: OOP

Description:

Mutating list methods such as 'append' or 'extend' return None instead of the (mutated) list itself. Sometimes, this is not the desired behaviour.
The Discussion on comp.lang.python resulted in the following solution.
The shown code is my own, while two other solutions are presented in the discussion.

Source: Text Source

def wrapedmeth(classname,meth):
    def _meth(self,*argl,**argd):
        getattr(super(globals()[classname],self),meth)(*argl,**argd)
        return self

    return _meth

class ReturnMeta(type):
    def __new__(cls,classname,bases,classdict):
        wrap = classdict.get('return_self_super_methods')
        if wrap is not None:
            for method in wrap:
                classdict[method] = wrapedmeth(classname,method)
        return super(ReturnMeta,cls).__new__(cls,classname,bases,classdict)

class mylist(list):
    __metaclass__ = ReturnMeta
    return_self_super_methods = ['append','extend','insert','remove','reverse','sort']


if __name__ == '__main__':
    print 'l = [1,2]'
    print 'mylist: print l.append(3)'
    l = mylist([1,2])
    print l.append(3)
    print 'list: print l.append(3)'
    l = [1,2]
    print l.append(3)

Discussion:

To have a reference to the (mutated) list returned is usefull, if one wants to chain commands such as mylistinstance.append(7).sort().
GvR (and others) took the decision not to allow this because it could be confusing programmers who thought that such methods would return a new object.
This leads to problems where the sideeffects are desired. Expressions inside lambda functions and list comprehension comes to mind.

During the news list dicussion, two alternative implementations were presented.
The first one is from Jacek Generowicz and doesn't involve meta classes:

class returner:

    def __init__(self, object):
        self.object = object

    def __getattr__(self, name):
        def proxy(*args, **kwds):
            getattr(self.object, name)(*args, **kwds)
            return self.object
        return proxy

lst = [1,2,3]
print lst.append(4) # Here you get None
print returner(lst).append(5) # Here you get the modified list.

def wrapReturning(func):
    def returningWrapper(*args, **kwds):
        func(*args, **kwds)
        return args[0]
    return returningWrapper


class metaReturner(type):
    ''' simplified metaReturner: deal with single inheritance only '''

    def __new__(mcl, className, classBases, classDict):

        # get the "real" base class, then wrap its mutators
        for base in classBases:
            if not isinstance(base, metaReturner):
                for mutator in classDict['__mutators__']:
                    classDict[mutator] = wrapReturning(getattr(base,
mutator))
                break

        # delegate the rest to built-in 'type'
        return type.__new__(mcl, className, classBases, classDict)

class Returner: __metaclass__ = metaReturner


# example usage

class returnerlist(Returner, list):
    __mutators__ = 'sort reverse append extend insert'.split()

print returnerlist('hello').extend('ciao').sort().reverse()