composition of functions (g o f)(x) translates to g(f(x)). In Python, @g @f def foo() translates to foo=g(f(foo).

-- псевдокод:
foo = decorator1 . decorator2 . decorator3 $ foo

-- или в 'столбик'
foo = decorator1
    . decorator2
    . decorator3
    $ foo

    @render('trip-edit.xsl')
    @permission('View trip')
    @global_view()
    @conf_info()
    @common_trip_info()
    def edit_trip(self, id):
        trips = Trips()
        the_trip = trips.get_trip_info(id)
        return dict(trip=the_trip)

...

    class update_route_rq(object):
        route_name = not_empty()&not_space()&has_len(max=200, min=0)&trunc(200)

    @render(raw=True)
    @permission('Edit geo')
    @validate_form(update_route_rq)
    def update_route(self):
        fd = Form_Data(self.request.form)
        fe =  Form_Errors(self.form_errors)

        (откушено)
...

The decorator statement is limited in what it can accept -- arbitrary expressions will not work. Guido preferred this because of a gut feeling .

Compose = fun(F,G) -> fun(X) -> F(G(X)) end end.

-- infix left 1
local (!>) = fun(x,f) -> f(x) end

-- TEST:
print $ "hello world" 
        !> string.upper 
        !> string.reverse

-- DLROW OLLEH

Z>Compose = fun(F,G) -> fun(X) -> F(G(X)) end end.
Z>

map_url( Url, { {validator, Validate}, {permission, Permission}, {handler, urlHandler}})

map_url( Url, { {{validate, validate_form},{validate_fuckup, invalid_form}, 
                 {{permission, some_permission},{permission_fuckup, access_denied}} 
                 {handler, some_url_handler}} )

class generic_decorator(object):
    def __init__(self):#, orig_self, *args, **kwargs):
        pass
        
    def get_origrun(self, args=None, kwargs=None):
        if args == None:
            args = self.func_args
        if kwargs == None:
            kwargs = self.func_kwargs

        #return decorated function object
        return lambda:self.orig_func(self.func_self, *args, **kwargs)

    #setter for decorated function object attr
    def set_function_attr(self, name, val):
        setattr(self.orig_func, name, val)

    def __new__(typ, *attr_args, **attr_kwargs):  # argument values of decorator

        def decorator(orig_func): # original function name
            self = object.__new__(typ)
            self.orig_func = orig_func
            self.__init__()

            attr_args
            attr_kwargs
           
            args, varargs, varkw, defaults = inspect.getargspec(orig_func)
            parameters = inspect.formatargspec(args, varargs, varkw, defaults)[1:-1]
    
            wrapper_func_str = """
def %s(%s):
    args, varargs, varkw, defaults = inspect.getargspec(%s)
    kw_args = dict.fromkeys(args)
    f_vals = []
    for key in args:
        kw_args[key] = locals()[key]
        f_vals.append(locals()[key])
    orig_self = f_vals[0]
    caller.func_self   = orig_self
    caller.func_args   = []
    caller.func_kwargs = kw_args
    return caller.__call__(*attr_args, **attr_kwargs)
"""%(orig_func.__name__, parameters, orig_func.__name__)

            exec_dict = locals()
            exec_dict.update(globals())
            exec_dict[orig_func.__name__] = orig_func
            exec_dict['orig_func'] = orig_func
            exec_dict['caller'] = self
            
            exec wrapper_func_str in exec_dict
            wrapper_func = locals()[orig_func.__name__]
            wrapper_func.__doc__ = orig_func.__doc__
            wrapper_func.__dict__ = orig_func.__dict__.copy()
            return wrapper_func
                                                        
        return decorator

dmz>    @render('trip-edit.xsl')
dmz>    @permission('View trip')
dmz>    @global_view()
dmz>    @conf_info()
dmz>    @common_trip_info()
dmz>    def edit_trip(self, id):
dmz>        trips = Trips()
dmz>        the_trip = trips.get_trip_info(id)
dmz>        return dict(trip=the_trip)
dmz>

@when_click("#myId1")
function onMyId1Click()
{
  ...
}
@when_selection_changed("#myId2")
function doSomething()
{
  ...
}

@exposed(всякая хрень) # тут только устанавливается атрибут метода, а привязка обработчика осуществляется позже 
def web_method(еще какая-то хрень)
   pass

A_P>>... вот мне интересно, когда люди начнут наконец придумывать "макросы" и "generic-function"

    Message =
    {
    constructor: function( text ) {  this.text = text;  },
        say: function(  )      {  stdout.println( this.text );  }
    }

   var x = function;
   var y = array[10];
   for(i=0; i < 10; i++) {
      y[i] = function(null, get_function(i)); // функция без имени
   }

   var z = get_some_value();
   y[z](12,23);

    var msg = new Message("Hello World!");
    msg.say(); // will print Hello World!

(self.onControlEvent || (self.onControlEvent = [])) += function(evt)
{
  if( evt.type == Event.BUTTON_CLICK && evt.target.match("bytton#my") )
    //doSomething usefull
}

@event_click("bytton#my")
  function doSomething()
  {
    usefull
  }

Stackless goes Limbo
Christian Tismer tismer@tismer.com
Wed, 24 Apr 2002 17:34:22 +0200
...
after some time of consideration,
I have decided to move the interface to Stackless
Python's multitasking towards the ideas behind
the Limbo Language.
...

Ann: Stackless Limbo Dancing Works Fine!
Christian Tismer tismer@tismer.com
Sat, 18 May 2002 03:30:41 +0200
...
This implementation tries to follow the concepts of the OCCAM/ALEF/LIMBO
languages by supporting the channel concept as the central
communication/blocking/control feature. Tasks do not communicate
directly, but through channels.
You might have guessed it: Stackless will try to implement/support
Hoare's CSP, finally.
...
— There isn't yet an ALT/PRI ALT construct like in OCCAM/ALEF/LIMBO.
This is most sophisticated and very hard to implement correctly!
...

class Foo {
  property bar(v)
  {
    get { return this._bar || 0; }
    set { this._bar = v; }
  }
}

var foo = new Foo();
foo.bar = 28;

Programming languages should be designed not by piling feature on top of feature, but by removing the weaknesses and restrictions that make additional features appear necessary.