[Python-Dev] method decorators (PEP 318)

[Jewett, Jim J]

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."