@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)

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

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

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

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
  }

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.

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

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

local Proto = {}
Proto.__index = Proto

function Proto:get() return self._bar or 0 end
function Proto:set(v) self._bar = v end

local function new() return setmetatable({},Proto) end

-- TEST:
local obj1 = new()
local obj2 = new()
obj1:set(42)

print(obj1:get()) ---> 42
print(obj2:get()) ---> 0

local Proto = {}
Proto.__index    = fun (self,prop)   -> rawget(self,prop) or 0 end
Proto.__newindex = fun (self,prop,v) -> rawset(self,prop,"decorated:"..v)  end

local fun new() ->
  setmetatable({},Proto)
end

-- TEST:
local obj1 = new()
local obj2 = new()

obj1.bar = 42

print(obj1.bar) --> decorated:42
print(obj2.bar) --> 0

Z>local Proto = {}
Z>Proto.__index    = fun (self,prop)   -> rawget(self,prop) or 0 end
Z>Proto.__newindex = fun (self,prop,v) -> rawset(self,prop,"decorated:"..v)  end

Z>local fun new() ->
Z>  setmetatable({},Proto)
Z>end
Z>

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

class Foo {  }

const Foo = new Class();

CS> ...
CS>  property bar(v)
CS>  {
CS>    get { return this._bar || 0; }
CS> ...
CS>

case name of
  | "bar" -> ...
  | "baz" -> ...
  | "bor" -> ...
end

local (\) = tostring

local Proto = {}
Proto.__index    = fun (self,prop)   -> rawget(self,prop) or 0 end


fun Proto.__newindex (self,prop,v) ->
  case v of
    | v if prop:match("^OnMouse") -> rawset(self,prop,"OnMouseMethod:"..\v)
    | v -> rawset(self,prop,v)
  end
end

local fun new() -> setmetatable({},Proto) end

-- TEST:
local obj1 = new()

obj1.OnMouseMove = fun()->end
print(obj1.OnMouseMove)     ---> OnMouseMethod:function: 0039D1A0

a = 1 b = 2 a = b + 1 c d()

CS>a = 1 b = 2 a = b + 1 c d()
CS>

a = 1 b = 2 a = b + 1 c= d() -- valid
a = 1 b = 2 a = b + 1 d()    -- valid

CS>class Foo {  } 
CS>

CS>const Foo = new Class();
CS>

[MyAttribute(1,2,3)]
[MyAttribute1("хо-хо")]
public class MyClass {
     [MyAttribute2]
     public void MyMethod( [OneModeAttribute]int xx) {
     }
     
     [I_Tut_Attribute]
     public int MyProperty {
        get { return InnerField; }
        set { InnerFiled = value; }
     }
}

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

Но это только зачаток мета-программирования.
хотя если позволить менять наборы аттрибутов в ран/бут-тайме - то будет уже немного теплее.

далее - Code-Dom.

A_P>>2. Нужен Code-Dom, что бы можно было вызывать операторы рефлексии и формировать код по мета-данным.
A_P>>   в т.ч. нужен доступ к актуальной мета-информации языка/виртуальной машины/рабочего пространства
A_P>>   (тут могут быть нюансы типа версионирования мета-информации)   

CS>С Code-Dom проблемы. Языки этой группы чаще всего используются в режиме eval (например JS).
CS>Т.е. скорость компиляциии критична. Вводить AST это вводить доп. фазу компиляции. 
CS>Без компромиса не обойтись. Собственно @decorator и есть такой компромис.

:-) главная задача инженера - искать и находить компромисы,
в них же и вся красота решений.

предлагаю рассмотреть такую конструкцию :
[code]
class MyClass (c1, c2, c3) {
    method Method1 (a, b, c) {
    }
    
    decorate (MyDecorator1, MyDecorator2) {
       method Method2 (a, b) {
       }
    }
}

decorate (MyDecorator3) {
    get-Method(MyClass, "Method2")
}

with-my-oo {
   class MyClass {
       super-method M1 (x,y,z) { ... }
   }
}

A_P>а когда оно есть — то различий уже нету. есть просто "программирование"

def-behavior MyBehavior (MyClass1, MyClass2) {

    for-css-selector ("#pushbutton1") {
        def-click-handler MyHandler1(tag, event) {
            di-ti;
        }

        def-style {
            width: 100;
            height: 20;
        }

        def-popup {
            // слово return не обязательно, пускай функция всегда возвращает последнее выражение.
            // "return" может оставаться в качестве flow-control-элемента, по-сути, это то же что и goto
            return get-popup();
        }
    }

    method get-popup() {
        //взять где-то запазухой...
    }
}

MyBehavior.method get-popup () {
   // вот так переопределим метод снаружи
}

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

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

self.addClickListener(function(){doSomething useful})

Г>Непонятно.

Г>self.addClickListener(function(){doSomething useful})
Г>

self.onControlEvent = function(evt) 
{
  if( evt.type == Event.BUTTON_CLICK )
  {
     if( evt.target.match("button#up") )
     {
       stdout << "Up!" << "\n";
     }
     else if( evt.target.match("button#down") )
     {
       stdout << "Down!" << "\n";
     }
  }
}

    @when Event.BUTTON_CLICK @on "button#up" :
    {
      stdout << "Up!" << "\n";
    }

    @when Event.BUTTON_CLICK @on "button#down" :
    {
      stdout << "Down!" << "\n";
    }

<html>
<head>
  <script type="text/tiscript">

    // decorator '@when' - filters event type and establishes chain of event handlers
    function @when(evtType, func)
    {
      function t(evt)
      {
        var r = false;
        if( evt.type == evtType) 
          r = func.call(this,evt);
        return t.next? t.next.call(this,evt):r; // even handlers chaining 
      }
      // note 'this' in decorators is current namespace - class or global (ns)
      var principal = this instanceof Behavior? this : self;
      t.next = principal.onControlEvent; 
      return principal.onControlEvent = t;
    }

    // decorator '@on' - filters evt.target by selector
    function @on(selector, func)
    {
      return function(evt)
      {
        if( evt.target.match(selector) )
          return func(evt);
      }
    }

    // tests of these two decorators:

    class Corpus:Behavior
    {
      @when Event.BUTTON_CLICK @on "button#up" :  
      {
        stdout << "Woohoo!" << "\n";
      }
    }

    @when Event.BUTTON_CLICK @on "button#up"
    function onUpClick()  
    {
      stdout << "Up!" << "\n";
    }

    @when Event.BUTTON_CLICK @on "button#down":
    {
      stdout << "Down!" << "\n";
    }
    
  </script>
  <style>
    body { prototype: Corpus; }
  </style>
</head>
<body>
  <button #up>Up</button>
  <button #down>Down</button>
</body>
</html>

Г>>Непонятно.

Г>>self.addClickListener(function(){doSomething useful})
Г>>

element.on_button_click do ... #predefined событие

element.on_behavior_event(:mycoolevent) do ... #не predefined событие :mycoolevent

#делаем так:
Hipster::Dom::Element.define_event(:mycoolevent, :cool_event)

#после этого работает такое:
element.on_cool_event do ... #TADA!

#а равно и:
element.on_cool_event('button#coolid') do ... #TADA!

А>Ни одной дополнительной конструкции в язык Никаких вопросов "а почему @when ... @on ...? а @when ... @where ... @then ... можно?"

А>Декораторы — это хорошая штука именно для АОП (типа, "а теперь вызов всех методов этого класса логгировать в файл"). Зачем они тут сдались —

@decor1 p11 p12 ... p1N @decor2 p21 p22 ... p2N @decor3 p31 p32 ... p3N function Foo(fp1 ... fpN ) { ... }

var Foo = @decor1 (p11, p12, ..., p1N, 
 @decor2 (p21, p22, ..., p2N, 
   @decor3 (p31, p32, ..., p3N, 
     function(fp1 ... fpN)
     {
       ... 
     }
)));

А>Все, здесь я потерялся. Что такое "syntax islands", что ты называешь "flat syntax", какие две системы —

element.on_button_click do ... #predefined событие

element.onClick = function() { ... } //predefined событие

var element = self.select( selector ); if(!element) throw "element " + selector + " not found";
element.onClick = function() { <код который нужно исполнить> };

@when Event.BUTTON_CLICK @on "selector": { <код который нужно исполнить> }

    // decorator '@params' - verification of parameters passed to the function
    function @params(param_types, func)
    {
      return function(params..)
      {
        if(params.length != param_types.length) throw "wrong number of parameters";
        var n = 0; for(var p in params)
          if(typeof p != param_types[n++]) 
            throw String.printf("parameter %d, expected %s but got %s", n, param_types[n-1], typeof p);
        return func.apply(this,params);
      }
    }

    @params [#integer,#integer]
    function SumInt(a,b)
    {
      return a + b;  
    }
    stdout << SumInt(2,2) << "\n"; // should pass
    stdout << SumInt(2,2.0) << "\n"; // should throw an error: "parameter 2, expected integer but got float"

@params [#integer, :v: v != 0 ] // lambda function - parameter's value tester
function DivInt(a,b)
{
  return a / b;  
}

CS>element.on_button_click do ... #predefined событие
CS>

CS>element.onClick = function() { ... } //predefined событие
CS>

CS>var element = self.select( selector ); if(!element) throw "element " + selector + " not found";
CS>element.onClick = function() { <код который нужно исполнить> };
CS>

Hipster.def_behavior('mycoolbehavior') do
  on_button_click do ...
end

#а потом просто <button behavior="~ mycoolbehavior"> в HTML 
#или [selector]{behavior: ~ mycoolbehavior;} в CSS

CS>@when Event.BUTTON_CLICK @on "selector": { <код который нужно исполнить> }
CS>

  this.select("button#up").onClick = function() { this. ...  }

  this.onControlEvent = function(evt) 
  { 
    if(evt.target.match("button#up") && evt.type == Event.BUTTON_CLICK )
    {
      this.doFoo();
    } 
    else if(evt.target.match("button#down") && evt.type == Event.BUTTON_CLICK )
    {
      this.doBar();
    } 
  }

@when Event.BUTTON_CLICK @on "button#up" :: this.doFoo();
@when Event.BUTTON_CLICK @on "button#down" :: this.doBar();

  this.onControlEvent = function(evt) 
  { 
    this.dispatch
    (
      [
        { when: Event.BUTTON_CLICK, on: "button#up", #doFoo }, 
        { when: Event.BUTTON_CLICK, on: "button#down", #doBar }
      ]
    );
  }

CS>  this.select("button#up").onClick = function() { this. ...  }
CS>

CS>  this.onControlEvent = function(evt) 
CS>  { 
CS>    if(evt.target.match("button#up") && evt.type == Event.BUTTON_CLICK )
CS>    {
CS>      this.doFoo();
CS>    } 
CS>    else if(evt.target.match("button#down") && evt.type == Event.BUTTON_CLICK )
CS>    {
CS>      this.doBar();
CS>    } 
CS>  }
CS>

self.on_click('button#up') do |event|
  #self == контейнер
  #event.target == кнопка
end

self.on_click('button#down') do |event|
  #self == контейнер
  #event.target == другая кнопка
end

#или:
Hipster.def_behavior('coo'){
  on_click('button#up') do ... end
  on_click('button#down') do ... end
}

    class Bar
    {
      // all instances will have at least two fields: 'three' и 'four'
      @this { three:3, four:4 };  // ';' at the end designates an empty decorator
    }

    // decorator '@this' - defines ctor that initializes instance by copying fields from proto object.
    //                     see sample below.     
    function @this(func, proto)
    {
      this[#this] = // define ctor in the class - function with name 'this'
        func ? 
          function(params..) { for(var n in proto) this[n] = proto[n]; func.apply(this,params); } 
        : function()         { for(var n in proto) this[n] = proto[n]; }
    }
    
    // testing it:
    
    class Foo
    {
      // Declaration of ctor plus two predefined fields for the instance. 
      // Notation is a bit unusual but works.
      
      @this { one:1, two:2 } :{} 
      // ^  ^                ^ 
      // |  |                | lambda function declaration (empty here) - body of the ctor. 
      // |  |
      // |  | object literal used for instance initialization
      // |
      // | name of our function-decorator (above).
    }

    class Bar
    {
      // Declaration of empty ctor - just predefined fields for the instance. 
      @this { three:3, four:4 };  // ';' at the end designates an empty decorator
    }
    
    var foo = new Foo();
    var bar = new Bar();

    stdout << foo.one << "\n"; // should print '1'
    stdout << foo.two << "\n"; // should print '2'

    //debug;    
    stdout << bar.three << "\n"; // should print '3'
    stdout << bar.four << "\n"; // should print '4'

    class Bar
    {
      function this { this.three = 3; this.four = 4; }
    }

А>self.on_click('button#up') do |event|
А>  #self == контейнер
А>  #event.target == кнопка
А>end
А>

А>Ну в чем проблема-то?

Element.on_click = function(selector, func) 
{
  var me = this;
  function thunk(evt)
  {
    if( evt.type == Event.BUTTON_CLICK && evt.target.match(selector) )
      func.call(me,evt);
    if( typeof thunk.next == #function ) thunk.next.call(me,evt);
  }
  thunk.next = this.onControlEvent;
  this.onControlEvent = thunk;
}

self.on_click("button#up", function(evt) 
 {
   // 'this' here is self
   // evt.target - the button
 });

@click : evt { 
  // 'this' here is self
  // evt.target - the button
} 
@click @on $(button#up) :
{   
  // 'this' here is self
}

CS>>@decor1 p11 p12 ... p1N @decor2 p21 p22 ... p2N @decor3 p31 p32 ... p3N function Foo(fp1 ... fpN ) { ... }
CS>>

    @params #integer #integer
    @returns #integer    
    function SumInt(a,b)
    {
      return a + b;  
    }

    // decorator '@params' - verification of parameters passed to the function
    function @params(func, param_types..)
    {
      return function(params..)
      {
        var n = 0;
        for(var p in params)
          if(typeof p != param_types[n++]) 
            throw String.printf("parameter %d, expected %s but got %s", n, param_types[n-1], typeof p);
        return func.apply(this,params);
      }
    }
    // decorator '@returns' - verification of returned value of the function
    function @returns(func, return_type)
    {
      return function(params..)
      {
        var rv = func.apply(this,params);
        if( typeof rv != return_type )
          throw String.printf("expected to return %s but got %s", return_type, typeof rv);
        return rv;
      }
    }

CS>>var Foo = @decor1 (p11, p12, ..., p1N, 
CS>> @decor2 (p21, p22, ..., p2N, 
CS>>   @decor3 (p31, p32, ..., p3N, 
CS>>     function(fp1 ... fpN)
CS>>     {
CS>>       ... 
CS>>     }
CS>>)));      
CS>>

<script>
  <!--
  document.write("</script>");
  -->
</script>

<?php  // Html safe containers 

$myOutput = <<<MYHTMLSAFEOUTPUT 
<?xml version="1.0"?> 
<html> 
  <title>PHP Example</title> 
  <body> 
   <p>...all sorts goes here...</p> 
  </body> 
</html> 
MYHTMLSAFEOUTPUT; 

echo $myOutput; 
?>