decorator with ```

[Roman Suzi]

One more crazy syntax before-def but which could be treated
more generally:

```""" Factory for new decorator syntaxes.

Keeps all proposals in a list and will recombine
them at random if called without a spec. """
staticmethod```
def makeDecoratorSyntax(spec=None):
raise NotImplementedException()

New execution block type (in addition to exec, eval and
interactive) could be added to allow needed behaviour.

Less-decorated are also fine:

```staticmethod```
def makeDecoratorSyntax(spec=None):
raise NotImplementedException()

Several block could also concatewnate:

```staticmethod```
```decor2```
def makeDecoratorSyntax(spec=None):
raise NotImplementedException()

Or use ; to put them into one line:

```staticmethod; decor2```
def makeDecoratorSyntax(spec=None):
raise NotImplementedException()
Of course, the same could be put AFTER def, like docstring.

Sincerely yours, Roman A.Suzi
--
- Petrozavodsk - Karelia - Russia - mailto:rn*@onego.ru -

[Sean Ross]

"Roman Suzi" <rn*@onego.ru> wrote in message
news:ma**************************************@pyth on.org...

One more crazy syntax before-def but which could be treated
more generally:

```""" Factory for new decorator syntaxes.

Keeps all proposals in a list and will recombine
them at random if called without a spec. """
staticmethod```
def makeDecoratorSyntax(spec=None):
raise NotImplementedException()

New execution block type (in addition to exec, eval and
interactive) could be added to allow needed behaviour.

[snip]

I think it would be interesting if triple-back-ticks could be used to
introduce a kind of meta-scope, using 'this' to refer to the namespace being
operated upon (so you wouldn't have to spell out the object's name all the
time). For example:
def makeDecoratorSyntax(spec=None):
```""" Factory for new decorator syntaxes.

Keeps all proposals in a list and will recombine
them at random if called without a spec.
"""
this = staticmethod(this) # <- transformation explicit
this.author = "somebody" # <- add attributes normally
```
raise NotImplementedException()

This idea could be used to do transformations on classes and modules as
well.

[Sean Ross]

"Sean Ross" <sr***@connectmail.carleton.ca> wrote in message
news:0z********************@news20.bellglobal.com. ..
[snip]

def makeDecoratorSyntax(spec=None):
```""" Factory for new decorator syntaxes.

Keeps all proposals in a list and will recombine
them at random if called without a spec.
"""
this = staticmethod(this) # <- transformation explicit
this.author = "somebody" # <- add attributes normally
```
raise NotImplementedException()

[snip]

It would work something like this:

def triplebacktick(this, transform):
this.doc = transform.doc
return transform(this)

def transform(f):
""" Factory for new decorator syntaxes.

Keeps all proposals in a list and will recombine
them at random if called without a spec.
"""
f = staticmethod(f)
f.author = "somebody"
return f

def makeDecoratorSyntax(spec=None):
raise NotImplementedException()

makeDecoratorSyntax = triplebacktick(makeDecoratorSyntax, transform)

[Bernhard Herzog]

Roman Suzi <rn*@onego.ru> writes:

```staticmethod```
def makeDecoratorSyntax(spec=None):
raise NotImplementedException()

That's already legal Python, although it's not very useful:

```staticmethod``` '\'"<type \\\'staticmethod\\\'>"\'' def makeDecoratorSyntax(spec=None): .... raise NotImplementedException()
....

Bernhard

--
Intevation GmbH http://intevation.de/
Skencil http://sketch.sourceforge.net/
Thuban http://thuban.intevation.org/