Yet another decorator proposal

[Marco Aschwanden]

Here is yet another decorator proposal:

def sumSequencesLengths(var1, var2):
"""Computes something very important.

__decorators__:
staticmethod
__parameters__:
var1=Sequences
var2=Sequences
__returns__:
int
"""
result = len(var1) + len(var2)
return result

Reasoning:
Decorators are important to communicate to the programmer. So, if someone
wants to use decorators she better writes a documentation for it. So why
not let the documentation enforce the whole decoration system?

The main advantages:
- Keeps the documentation up-to-date! The first language to do so (-
doesn't it?)
- Enforces Python's readability further.
- Needs no new language constructs.


The main disadvantages:
- The values are frozen... the __decorators__ are set in a static string
- The definition follows after the def
- A "static" description has an impact on the "acting" program

There are really more pros and cons... it might be also only a
"Schnapsidee" - after all I am no language designer.

Have a nice day,
Marco

 

[Paul Rubin]

Here is yet another decorator proposal:

def sumSequencesLengths(var1, var2):
"""Computes something very important.

__decorators__:
staticmethod

I think you are onto something. The particular syntax you proposed
has shortcomings, but maybe improvements are possible.

 

[Reinhold Birkenfeld]

Here is yet another decorator proposal:

def sumSequencesLengths(var1, var2):
"""Computes something very important.

__decorators__:
staticmethod

I think this is not a great idea, for several reasons:

- Decorators are inside the function. I'm not generally against that,
but I agree that decorators are something important that, e.g., should
not be folded away.
- Decorators are "hidden" in a string. This is almost as ugly as the
meta-constructs some other languages have, hiding vital information in
comments.
- The indentation, if it is a crucial part of your proposal, is not
clear. Remember that docstrings are strings, and as such have no notion
of the current indentation of the function block.

Sorry, but if decorators should go into the body, I'm sure they will
take such a form:

def SomeFunction(param):
meta:
staticmethod
<code>

Reinhold

 

[Christopher T King]

- Decorators are "hidden" in a string. This is almost as ugly as the
meta-constructs some other languages have, hiding vital information in
comments.

Also, don't forget docstrings get thrown away when using python -OO.
Great voodoo would be needed to prevent this from happening.

 

[Marco Aschwanden]

Also, don't forget docstrings get thrown away when using python -OO.
Great voodoo would be needed to prevent this from happening.

<magic>
By now the compiler takes the first triple-quoted-string and sets it on
the object's __doc__-var. Even in -00 mode the compiler has to find the
triple-quoted-string... well on his way he can pick out the modifiers
before throwing the doc string away, and set the appropiate object vars
(__decorators__, __parameters__, ...).

Doesn't seem too complicated to me.
</magic>

Magic greetings,
Marco - The magician

 

[Christopher T King]

<magic>

Like I said, great voodoo

 

[Reinhold Birkenfeld]

<magic>
By now the compiler takes the first triple-quoted-string and sets it on
the object's __doc__-var.

It doesn't really need to be triple-quoted, does it?

Reinhold

 

[Marco Aschwanden]

It doesn't really need to be triple-quoted, does it?

.... "A little test."
.... print "hi"
....
It seems not, but I am not aware what language reference says to that...

Marco