Объектная система alterator.

В текущей нестабильной ветке alterator произошло большое изменение, там внедрены объекты. Зачем это нужно? Нужно это для того чтобы поддерживать код alterator было легче, чтобы убрать старые хаки, уменьшить количество cond и case, затрудняющее чтение. Что это такое? Читайте далее ....

Меченные функции

В Scheme, как во всяком уважающем себя функциональном языке, возможно построить структуру данных «пара» не пользуясь встроенными типами данных, а прямо на функциях. Например, это можно сделать так:
(define (my-cons x y) (lambda (cmd) (case cmd ((first) x) ((second) y))))) (define (my-car pair) (pair 'first)) (define (my-cdr pair) (pair 'second))
Однако всё не так хорошо как хотелось бы. Пользуясь только одними функциями невозможно сделать предикат pair?, то есть функцию, которая получив на вход некий объект, выдаёт истина только в случае если этот объект определённая выше структура «пара». Почему? Да очень просто. Вы не можете различать процедуры между собой. Ибо единственный способ различить подобные процедуры, это только запускать их, но результатом запуска может быть что угодно, включая попадание в вечный цикл. Говоря умнее, мы можем построить только полухарактеристическую функцию для множества пар.

Отсюда мораль, что требуется со стороны языка дополнительный способ «пометить» процедуры. Тогда мы могли бы гарантированно различать разные классы процедур между собой. Большинство реализаций Scheme поддерживают данный приём в том или ином виде.

Итак появляются первые две процедуры нашей объектной системы:

• set-instance! – «пометить функцию» (то что эта функция с side-effect исключительно особенность используемой на данный момент реализации Scheme)
• instance-of – получить «метку» процедуры. Для не процедурных типов данных возращается «псевдо-метка», например для строки – это <string>, для чисел – <number>.
• is-a? – предикат который помогает проверить какой разновидности та или иная процедура

Пример:
(define (func) #f) ; некоторая функция (set-instance! 'my-function func) ; пометили функцию (instance-of func) ==> вернёт my-function (instance-of (lambda() #f)) ==> вернёт <procedure> (is-a? "some-string" <string>) ==> вернёт #t

Ура! Теперь мы можем различать между собой процедуры, чем это хорошо для нас – увидите чуть позже.

Объекты – это замыкания для бедных

Эта цитата принадлежит Norman Adams и сейчас вы убедитесь насколько это верно ;)

Любая созданная процедура, запоминает своё окружение, вместе со всеми определёнными там переменными и другими функциями. При этом запоминает настолько хорошо, что: куда бы далее вы не передавали эту процедуру, она будет работать именно с тем окружением в котором родилась (подобно тому как циплята, кого увидят первым, вылупившись из яйца, того и считают мамой), данные окружении будут существовать до тех пор, пока они требуются хотя бы одной процедуре. Например:

(define (make+ x) (lambda (y) (+ x y))) (define x 10) (define +three (make+ 3)) (+three 5) ==> вернёт восемь. (define +five (make+ 5)) (+five 5) ==> вернёт десять.

Здесь, функция +three, появившись запомнила, что x это 3, и при всех последующих запусках будет работать именно с этим значением, даже если мы явно зададим x в значение 10.

Итак, у нас есть «память», а если есть «память», значит можно сделать функции с состоянием, иначе говоря объекты.
Вот например простейший объект, изображающий точку на плоскости:
(define (make-point-2d x y) (lambda (op . value) (case op ((get-x) x) ((get-y) y) ((set-x) (set! x (car value))) ((set-y) (set! y (car value)))))) (define point (make-point-2d 3 4)) (point 'get-x) ==> вернёт 3 (point 'set-x 10) ; запомнит в своём окружении новое значение x (point 'get-x) ==> вернёт 10

Вот теперь ясно видно, что имея замечательное свойство «памяти», можно создавать то что в других языках программирования называют объектами, то есть совокупность данных и методов, работающих с этими данными. То как именно строить объекты – никто вас не ограничивает, поэтому существует множество вариантов объектных систем для Scheme. Система объектов Alterator похожа на объектную систему T.

Методы или сообщения

Работают с объектами, как правило, одним из двумя способами: явно обращаясь в методам или данным или передавая объекту сообщение. Эти способы совершенно равноценны. Просто в одном языке удобнее вызвать метод:
object.method(params)
В другом, послать объекту сообщение с желанием выполнить метод:
(send-message object 'method params)
Как догадываетесь, в LISP принято использовать второй способ.

Простые объекты

На вводимые дальше объекты можно смотреть как на существенно улучшенные функции.
С одной стороны объект будет содержать в себе собственно тело функции, с другой стороны у него будет «вторая дверь» через которую можно будет вызывать определённые в объекте операции. То есть мы получаем объект «функция с рычагами».

Если захочется различать объекты между собой, то в конструирующей его процедуре, воспользуйтесь set-instance!.

Общий формат процедуры создания объектов следующий:
(object <proc> <methods>)
<proc> – выражение которое будет исполняться при каждом вызове объекта (дверь #1). <methods> – набор определённых операций (дверь #2). Операций может и не быть.
Вырожденный случай (есть только дверь #1):
(object (lambda args #f))
Это тоже самое что и просто процедура:
(lambda args #f)

Методы описываются в следующем формате:
((name self args) body)
Здесь:

• name – имя операции.
• self – ссылка на сам объект. Очень полезно когда из одного метода хочется вызвать другой метод того же объекта.
• args – необязательные дополнительные параметры метода.
• body – тело метода.

Операции

Как же войти во вторую дверь? Для этого существуют так называемые операции.
Создаётся операция при помощи инструкции (operation имя)
Можно сразу создать и определить операцию (define-operation имя). Последняя конструкция полностью аналогична операции (define имя (operation имя))

Создадим объект точки на плоскости:
(define (make-point-2d x y) (object 'called ((get-x self) x) ((get-y self) y) ((set-x self value) (set! x value)) ((set-y self value) (set! y value)))) (define-operation get-x) (define-operation set-x) (point) ==> при исполнении вернёт символ 'called как и просили (define point (make-point-2d 3 4)) (get-x point) ==> вернёт 3 (set-x point 10) ==> запомнится новое значение x (get-x point) ==> вернёт 10

Составные объекты

Можно усложнять «маршрутизацию сообщений», тем самым создавая то, что в других языках программирования называют «наследованием» и «иерархией объектов».

Для комбинирования объектов используется процедура join. В результате применения join
объектам (object proc1 method11 method12 ...) (object proc2 method21 method22 ...)
Получится объект (object proc1 method11 method12 ... method21 method22 ... ).

Создадим объект точки в пространстве:
(define (make-point-3d x y z) (join (make-point-2d x y) (object #f ((get-z self) z) ((set-z self value) (set! z value))))) (define-operation get-x) (define-operation get-z) (define point (make-point-3d 3 4 5)) (get-x point) ==> вернёт 3 (get-z point) ==> вернёт 5 (point) ==> вернёт 'called как если бы это был вызван point-2d.

Все примеры выше не являются по сути вызываемыми объекты. Где же могут быть полезны настояшие дву-дверные функции-объекты.

Возьмём пример из самого alterator.

Создадим объект «пустой атрибут». Если у него спросить имя атрибута, то он его вернёт, а любые попытки вызова интерпретируются как пожелание задать данному атрибуту значение и в результате возвращается объект «аттрибут со значением». Последний также воспринимает сообщения на предмет получения его имени и значения, а все попытки вызова интерпретирует как пожлание добавить ещё одно значение, то есть в результате возвращается аттрибут с расширенным значением.
Пример:
width --> это пустой атрибут (name-of width) ==> возвращает имя атрибута, то есть width (width 10) ==> возвращает "атрибут со значением" 10 (name-of (width 10)) ==> имя width (value-of (width 10)) ==> значение 10 ((width 10) 20) ==> "атрибут со значением" (10 20).
Такое поведение очень удобно использовать в описании интерфейса
(label "aaa" width 20) (some-widget (dimensions 10 50) color 'blue ...)

Описываются эти необычные объекты очень и очень просто:
(define (make-empty-attribute attr-name) (set-instance! '<empty-attribute> (object (lambda args (apply make-attribute attr-name args)) ((name-of self) attr-name)))) ;create attribute with value (define (make-attribute attr-name . attr-value) (set-instance! '<attribute> (object (lambda args (apply make-attribute attr-name (append attr-value args))) ((name-of self) attr-name) ((value-of self) attr-value))))

Ну вот и всё. Объектная система простая – как и всё в Scheme.

Объекты в alterator

Какие же объекты применяются в самом alterator?

• <empty-attribute> (конструктор make-empty-attribute) – применяется в описании интерфейса, олицетворяет собой пустой атрибут, обрабатывается так, что «забирается» следующее за ним значение. Это позволяет делать записи вида: (vbox width 10)
• <attribute> (конструктор make-attribute)- применяется в описании интерфейса, олицетворяет собой атрибут с заданным значением, позволяет делать записи вида: (vbox (with 10) (height 20)) . Это полезно когда надо задать в аттрибуте сразу несколько значений.
• <widget-holder> – обёрточные объекты для виджетов. Под этим instance скрываются два вида объекта:
  • (конструктор make-widget-holder) – применяется внутри движка look. Используется для создания отложенного создания вложенных вижетов. Ибо: аргументы функции обрабатываются от конца к началу, а виджеты надо создавать в обратном порядке. Например для вижета (vbox (label “test”)) сначала обрабатывается label, а потом vbox. Однако реально надо сначала создать vbox, а потом label с родительским виджетом vbox. Этот объект после создания виджета остаётся основным интерфейсом к нему. Объекты типа widget-holder создаются во время обработки процедур видимых в описании интерфейса, таких как hbox,label,vbox.
  • (конструктор make-id-holder) – лёгкая обёртка для того чтобы спрятать опасную операцию set!. Работает крайне примитивно: при первом обращении к нему, он запоминает переданный ему объект, при всех последующих обращениях он ''тупо» транслирует к нему все запросы.
  Оба этих обёрточных класса поддерживают важную операцию – get-content. Которая позволяет раскрутить все «фантики» и добраться до реального виджета, чтобы произвести над ним нужные операции.
  
• <widget> (конструктор make-widget) – содержит в себе уже объекты соответстующие реальным виджетам (qt,html, etc.). Содержит диспечер callback'ов событий.
• <event-callback> (конструктор make-event-callback) – хранит в себе отложенное действие, вызываемое для облуживания тех или иных событий интерфейса. Создаётся в момент обработки процедур, видимых в описании интерфейса, таких как on-click,on-select .
• <qt-widget> (конструктор make-qt-widget) – последняя граница перед миром Qt.

Ещё планируется введение объектов для нативных бакендов alterator, и объекта command но это дело будущего.

....