[Python-Dev] method decorators (PEP 318)

[Greg Ewing]

Robert Mollitor <mollitor at earthlink.net>:

> Not only would we want "synchronized(classmethod(f))" to work, but we
> would probably want "classmethod(synchronized(f))" to work
> identically.  This is not easy unless either the implementation of
> each was aware of the other (or at least the possibility of the
> other), or all transformers must be written to a tight specification.

For that to work, all transformers would have to be prepared to
receive a descriptor instead of a callable, extract the underlying
callable, transform that, and then wrap the result back up in a
descriptor of the same type.

While that could be done for specific types of descriptor, it couldn't
be done in general because there's no standard for callable-wrapping
descriptors concerning how to extract the wrapped callable.

Also, it would still only be possible to have at most *one*
descriptor-creating transformer in the chain. That's probably
unavoidable, since in general different kinds of descriptors are going
to be fundamentally incompatible with each other.  This probably isn't
a disadvantage, since it wouldn't make sense to combine such
descriptors anyway (e.g a method can't be both a classmethod and a
staticmethod).

It seems we have two quite different kinds of transformer here: (1)
those that take a callable and return another callable; (2) those that
take a callable and return a descriptor.

The differences between them are substantial. Type 1 transformers are
easily chained, and it seems people will often want to do so. It also
seems that for the most part it will be easy to design them so that
transformers with orthogonal effects can be chained in any order.

On the other hand, it seems that it will usually make sense only to
have *one* transformer of type 2 in any given definition, and it
*must* be applied last.

Particularly considering the latter restriction, I'm wondering whether
these should be treated differently in the syntax. Maybe something
like

  def [type2trans] foo(args) [type1trans, type1trans...]:
    ...

or

  def foo [type2trans] (args) [type1trans, type1trans...]:
    ...

This might also help satisfy Guido's concerns about the positioning
of 'classmethod' and 'staticmethod', since, being type 2 transformers,
they would go up front.

Greg Ewing, Computer Science Dept, +--------------------------------------+
University of Canterbury,	   | A citizen of NewZealandCorp, a	  |
Christchurch, New Zealand	   | wholly-owned subsidiary of USA Inc.  |
greg at cosc.canterbury.ac.nz	   +--------------------------------------+