ООП, замыкания, или изобретая велосипеды...

Тут одна занятная штука нарисовалась. Вот возьмем объект (экземпляр класса) из ООП. Упрощенно, его методы можно считать обычными функциями, в контекст которых захвачена переменная this (или self, кому что нравится). Поясню на примере языка Python, что такое замыкание.

def makeAdder(num):
   def adder(num1):
       return num + num1
   return adder

sevenAdder = makeAdder(7)
print sevenAdder(2) # => 9

В данном случае вложенная функция adder при своем создании захватывает окружающий ее контекст. В частности, в этом контексте оказывается переданная в функцию makeAdder переменная num.
И вот пришла идея создать на такой основе что-то вроде ООП. Вот что в результате получилось:

from bicycleoop import *

@klass()
def Superclass(this, kls):
   kls.AAA = 'Superclass_AAA'

   @method
   def say1():
       print 'from super.say1: [arg1 = %s];' % this.arg1

   @method
   def say3():
       print 'from say3;'

   @method
   def say5():
       print 'from say5:',
       this.say2()

   @method
   def say6():
       print 'from super say6;'

   @method
   def say7():
       print 'from say7: this.AAA='+this.klass.AAA, 'super.AAA='+this.super.klass.AAA

@klass(Superclass)
def Klass1(this, kls):
   kls.AAA = 'Klass1_AAA'

   @klassmethod
   def klm1():
       print 'KlassMethod1: Klass1.AAA='+kls.AAA, 'Superclass.AAA='+kls.superClass.AAA

   @method
   def __init__(arg1, arg2):
       print 'creating instance of %s with arg1=%s, arg2=%s' % (this.klass.name, arg1, arg2)
       this.arg1 = arg1
       this.arg2 = arg2

   @method
   def say1():
       print "from say1: [arg1 = %s]" % this.arg1

   @method
   def say2():
       print "from say2: [arg2 = %s]" % this.arg2,
       this.say1()

   @method
   def say4():
       print 'from say4:',
       this.say3()

   @method
   def say6():
       print 'from say6:',
       this.super.say6()

print Superclass.AAA        # => Superclass_AAA
print Klass1.AAA            # => Klass1_AAA

k = Klass1.new(17, "Hello") # => creating instance of Klass1 with arg1=17, arg2=Hello
k.say1          # => from say1: [arg1 = 17]
k.super.say1()  # => from super.say1: [arg1 = 17];
k.say2()        # => from say2: [arg2 = Hello] from say1: [arg1 = 17]
k.say3()        # => from say3;
k.say4()        # => from say4: from say3;
k.say5()        # => from say5: from say2: [arg2 = Hello] from say1: [arg1 = 17]
k.say6()        # => from say6: from super say6;
k.say7()        # => from say7: this.AAA=Klass1_AAA super.AAA=Superclass_AAA

k1 = Klass1.new(20, "sdfs") # => creating instance of Klass1 with arg1=20, arg2=sdfs
k.say2()        # => from say2: [arg2 = Hello] from say1: [arg1 = 17]
k1.say2()       # => from say2: [arg2 = sdfs] from say1: [arg1 = 20]

print Superclass.AAA        # => Superclass_AAA
print Klass1.AAA            # => Klass1_AAA

Klass1.klm1()     # => KlassMethod1: Klass1.AAA=Klass1_AAA Superclass.AAA=Superclass_AAA

sup = Superclass.new()

print k.methods.keys()      # => ['say7', 'say6', 'say5', 'say4', 'say3', 'say2', 'say1', '__init__']
print sup.methods.keys()    # => ['say7', 'say6', 'say5', 'say3', 'say1']

print k.klass == Klass1                                 # => True
print k.super.klass == Klass1.superClass == Superclass  # => True

o1 = obj()

Klass1(o1, Klass1)
o1.arg1 = 15
o1.say1()   # => from say1: [arg1 = 15]

Как видим, реализовано наследование (одиночное, правда), обычные и статические методы (методы класса), и статические поля тоже. Создание объектов реализовано в стиле Смоллтолк и Руби (через Klass.new). В объявлении класса передаются 2 переменные (this и kls), что кажется немного странным. Но это, во-первых, более pythonic (Explicit is better than implicit) а, во-вторых, это как раз те переменные, которые будут "замкнуты" в замыкания из функций-методов. Замечу, что они инициализируются лишь в момент создания объекта.
Для выразительности объявление классов и методов выполненно в виде декораторов. Декоратор (для тех, кто не в курсе) это функциональность, работающаю следующим образом: код

@decor
def f(arg):
    # do smth
    pass

эквивалентен коду:

def f(arg):
    # do smth
    pass

f = decor(f)

То есть декоратор - это обычная функия, которой мы "декорируем" некоторую другую функцию. Я полагаю это имеет отношение к AOP и вероятно, этот механизм призван внести большую выразительность и декларативность в код. Подробнее про декораторы читать тут.
А вот описание модуля с декораторами:

# this is file bicycleoop.py
import sys

def obj():
   def _obj():pass
   return _obj

def klass(*args):
   # args - superclasses, now only 1 allowed
   def classDecorator(classFunc):
       if len(args) == 1:
           _superClass = args[0]
       else:
           _superClass = None

       def copyMethodsTo(this):
           this.klass = classFunc

           if _superClass:
               this.klass.superClass = _superClass
               this.klass.superClass.copyMethodsTo(this)# now into this exist all functions with captured 'this'
               this.klass = classFunc # return back after ^^^ changes it
               this.super = obj()
               this.super.klass = _superClass
               for meth in this.methods.keys():
                   setattr(this.super, meth, this.methods[meth])
           else:
               classFunc.superClass = None

           this.klass(this, obj()) # initing methods
           return this

       def new(*a, **k):
           this = obj()
           copyMethodsTo(this)
           this.__init__(*a, **k)
           return this

       classFunc.copyMethodsTo = copyMethodsTo
       classFunc.new = new
       classFunc.name = classFunc.func_name

       classFunc(obj(), classFunc) # for class vars and class methods

       return classFunc

   return classDecorator

def method(methodFunc):
   this = sys._getframe().f_back.f_locals['this']
   setattr(this, methodFunc.func_name, methodFunc)
   if not hasattr(this, 'methods'):
       this.methods = {}
   this.methods[methodFunc.func_name] = methodFunc
   return methodFunc

def klassmethod(methodFunc):
   kls = sys._getframe().f_back.f_locals['kls']
   setattr(kls, methodFunc.func_name, methodFunc)
   if not hasattr(kls, 'klassmethods'):
       kls.klassmethods = {}
   kls.klassmethods[methodFunc.func_name] = methodFunc
   return methodFunc

Тут есть пару моментов. Такой вот замысловатый код:

sys._getframe().f_back.f_locals['this']

используется, чтоб подняться вверх по стеку вызовов функций и получить из локального контекста внешней функции необходимые переменные. А второй довольно смешной хак тут - использование все тех же функций в качестве объектов (функция obj на самом деле возвращает новую пустую функцию, которую мы используем совсем не по назначению))), которым можно присваивать любые поля, ввиду того, что такой код, как видим, не хочет работать:

>>> o = object()
>>> o.a = 123

Traceback (most recent call last):
File "", line 1, in 
o.a = 123
AttributeError: 'object' object has no attribute 'a'
>>>

Заключение:
Полезность (практическая) этого дела нулевая, но позволяет хорошенько размять мозг. И, кроме того, получилось довольно концептуально: ключевое слово языка class использовано не было. Правда опять же, ООП-природа языка была использована, по этому все довольно не честно, но мы никому ничего и не были обязаны =)

PS. Извините за длинный пост. Кто-нибудь может подсказать как показывать только часть поста со ссылкой "читать далее" на лицевой странице?