[Python-Dev] method decorators (PEP 318) (original) (raw)

Jewett, Jim J jim.jewett at eds.com
Fri Mar 26 16:17:05 EST 2004

Guido van Rossum:

... for decorators spelled with a single word, like classmethod, ... as early as reasonable in the function definition

def foobar(cls, blooh, blah) [classmethod]:

hides a more important fact for understanding it (classmethod) behind some less important facts (the argument list). I would much rather see this:

def foobar [classmethod] (cls, blooh, blah):

One alternative placed it earlier still, in a second header clause.

using:
    classmethod
def foobar(cls, blooh, blah):
    pass

This isn't as good for single short decorators, but it does scale up better than anything which adds directly to the def clause.

using:
    metadata(author="GvR",
             version="1.0",
             copyright="PSF",
             ...)
    deprecated
def foobar (self, blooh, blah):
    for bl, oh in blooh:
        print oh(blah(bl))

    for bl, oh in blooh:
        print oh(blah(bl))

It still risks hiding a few transformations in a large group of annotations.

Using both the header and the suite creates more separation, but it is an option.

using classmethod:
    deprecated        
    metadata(author="GvR",
             version="1.0",
             copyright="PSF",
             ...)
def foobar (cls, blooh, blah):
    for bl, oh in blooh:
        print oh(blah(bl))

I want to reserve the leading dot for attribute assignment to a special object specified by a 'with' statement, e.g.

with self: .foo = [1, 2, 3] .bar(4, .foo)

Would the about-to-be-defined object be available when specifying that special object? (I've used "this" to separate it from the enclosing class that "self" would refer to.)

with this:
    .note = [1,2,3]
def foo(args):
    pass

or even

with proxy_dict(this):
    .note = [1,2,3]
def foo(args):
    pass

How important is the annotation/transformation distinction?

with this:
    .note = [1,2,3]
using:
    classmethod
def foo(args):
    pass

Phillip J. Eby:

Okay, then how about:

def foobar(cls,blooh, blah): [classmethod] """This is a class method""" # body

The above is already legal syntax, it just doesn't do much. It does keep the """ """ from being a docstring, which in turn keeps it from being optimized out.

def foobar(args):
    [1,2,3]
    """Here's proof you stole my code in a careless manner!"""
    pass

Breaking that particular usage might be amusing, but I'm not so happy about having to look farther and farther ahead to guess where the magic ends. @classmethod at least says "This part is still magic."

More information about the Python-Dev mailing list