There's been a bit of a fight in the Python community over the syntax which function decorators should adopt. There is a syntax adopted in the current alpha release which many Pythonistas dislike. I wrote a proposal over the weekend for the strongest replacement candidate; since IWETHEY is My Own Personal Blog, you all get to comment. :) Plus, I'd just like someone who's not a Python user to tell me what they think. Outsider perspectives are always good. Just don't propose new syntax! We have far too many variants already.

The thing, itself: [link|http://www.aminus.org/rbre/python/pydec.html|http://www.aminus.or...python/pydec.html]

Once the discussion dies down on the newsgroup, I'll call for signatories and send it to Guido (Python's Benevolent Dictator For Life) for consideration.

'Decorators', by the way, are callables which you pass a function and get back a function. The decorator can add attributes to that function, wrap it with another, or give you back a new function object. Whatever you want. The old way of doing this was

def foo(cls):\n    pass\nfoo = classmethod(foo)\nfoo.author = "Robert Brewer"

The current alpha syntax would be

@classmethod\n@funcattrs(author="Robert Brewer")\ndef foo(cls):\n    pass

and the proposal suggests

using:\n    classmethod\n    funcattrs(author="Robert Brewer")\ndef foo(cls):\n    pass

...which isn't the best reason to introduce new syntax, but it's going in one way or another.

Here's an example of the old way:

    def frombuf(cls, buf):\n        """Construct a TarInfo object from a 512 byte string buffer.\n        """\n        tarinfo = cls()\n        tarinfo.name   =  nts(buf[0:100])\n        tarinfo.mode   = int(buf[100:108], 8)\n        tarinfo.uid    = int(buf[108:116],8)\n        tarinfo.gid    = int(buf[116:124],8)\n        tarinfo.size   = long(buf[124:136], 8)\n        tarinfo.mtime  = long(buf[136:148], 8)\n        tarinfo.chksum = int(buf[148:156], 8)\n        tarinfo.type   = buf[156:157]\n        tarinfo.linkname = nts(buf[157:257])\n        tarinfo.uname  = nts(buf[265:297])\n        tarinfo.gname  = nts(buf[297:329])\n        try:\n            tarinfo.devmajor = int(buf[329:337], 8)\n            tarinfo.devminor = int(buf[337:345], 8)\n        except ValueError:\n            tarinfo.devmajor = tarinfo.devmajor = 0\n        tarinfo.prefix = buf[345:500]\n\n        # The prefix field is used for filenames > 100 in\n        # the POSIX standard.\n        # name = prefix + '/' + name\n        if tarinfo.type != GNUTYPE_SPARSE:\n            tarinfo.name = normpath(os.path.join(nts(tarinfo.prefix), tarinfo.name))\n\n        # Directory names should have a '/' at the end.\n        if tarinfo.isdir() and tarinfo.name[-1:] != "/":\n            tarinfo.name += "/"\n        return tarinfo\n\n    frombuf = classmethod(frombuf)

Two things are "wrong":

1) The notation that this is a class method is a long way from the declaration of the function itself, and often gets missed when reading source code.

2) One has to type "frombuf" three times. In particular, some integration projects require you to a) wrap functions and b) use extremely long method names.

(my 'e' key has been failing me recently)

Normal Python has classes which possess member functions (methods). Normal methods always take an initial parameter (usually called 'self') which refers to the instance of the class. For example:

class Ball(object):\n    def __init__(self):\n        self.x = 0\n\n    def bounce(self, distance):\n        self.x += distance\n\nbasketball = Ball()\nbasketball.bounce(3)

Inside 'bounce' (when we call it), 'self' refers to the basketball object instance, so you can manipulate it. Sometimes, however, you want a method which doesn't care about the instance, only the class. Often, these are constructors:

class Ball(object):\n    def __init__(self):\n        self.x = 0\n        self.y = 0\n\n    def displaced(cls, x, y):\n        b = cls()\n        b.x = x\n        b.y = y\n        return b\n    displaced = classmethod(displaced)\n\nbasketball = Ball.displaced(3, 4)\nbasketball.bounce(3)

classmethod() takes what would have been a normal member function and makes it a class method. Class methods don't receive an instance as the first argument, but a class instead (classes are objects in Python). You have to pass in the class for the method to work on it. The above is pretty trivial--we could have just written b = Ball() instead of b = cls(), but once you start subclassing, you can take advantage of the generic nature of cls.

Hope that helped <:)

However, we all (Guido included ;) learned a lot about community involvement in the design process. I'm quite pleased with the meta-outcomes. You can read the whole rejection notice at [link|http://article.gmane.org/gmane.comp.python.devel/63486|http://article.gmane...ython.devel/63486]