Объектная система 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! func 'my-function) ; пометили функцию (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 и YASOS.

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

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

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

Основной компонент объектной системы – диспечер методов, создаётся процедурой object.
Данные для диспечера методов, создаются благодаря свойству замыкания, когда объект создаётся при помощи некоторой функции – коструктора. Создаваемому диспечеру в качестве параметра передаётся метка, которую потом можно изучать с помощью процедур instance-of и is-a?.
Создадим объект точки на плоскости:
(define (make-point-2d x y) (object <point> ((get-x self) x) ((get-y self) y) ((set-x self value) (set! x value)) ((set-y self value) (set! y value))))
В описании мы задали диспечеру метку <point> и перечислили методы. В описании каждого метода перечисляются его имя и параметры, первый параметр, обязательный – self. Это ссылка диспечера самого на себя – очень полезное свойство. Данный параметр всегда передаётся неявно, поэтому при посылке сообщений его не надо указывать.

Созданный диспечер бесполезно запускать неспосредственно, он ведь занимается только разбором какой метод надо вызвать и как. Если мы хотим сделать «запускаемый» объект, то надо воспользоваться процедурой callable. В результате применения callable, мы получим процедуру, которая будет заниматься передачей сообщений диспечеру и запуском требуемых методов. Метка у этой процедуры будет в точности такая же, как была у объекта
(define point (make-point-2d 3 4)) (instance-of point) ==> вернётся <point> (define cpoint (callable point)) (instance-of cpoint) ==> вернётся <point> (cpoint 'get-x) ==> вернёт 3 (cpoint 'set-x 10) ==> запомнится новое значение x (cpoint 'get-x) ==> вернёт 10

Если вы хотите всегда работать с «вызываемыми» объектами, то можно включить вызов callable прямо в конструктор:
(define (make-point-2d x y) (callable (object ... .... (define point (make-point-2d 3 4)) (point 'get-x) ==> вернёт 3

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

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

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

Обратите внимение, что join может работать только с диспечерами. Вызываемые объекты объединять уже нельзя.

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

Обратите внимание, что первым параметром к join также как и к object идёт «метка». Также стоит заметить что меня никто не ограничивает в выборе метки. Если я уверен, что point-3d потом распознается и будет работать так же как и обычная точка, могу ему дать ту же самую метку.

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

Ну и наконец, последний способ маршрутизации: можно определить точку перехвата всех необработанных сообщений. То есть, если в диспечер приходит сообщение, и никто не найден, то данный специальный метод получит управление. Понятно, что нет смысла в комбинированном объекте в первом же компоненте делать такой перехват – до других компонент сообщения просто не будут доходить.

Оформляется такой обработчик как метод с именем совпадающем с меткой объекта (следовательно он может быть только один, что вполне логично).

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

Описываются эти объекты очень и очень просто:
(define (make-empty-attribute attr-name) (callable (object <empty-attribute> ((<name> self) attr-name) ((<empty-attribute> self . args) (apply make-attribute attr-name args))))) (define (make-attribute attr-name . attr-value) (callable (object <attribute> ((<name> self) attr-name) ((<value> self) attr-value) ((<attribute> self . args) (apply make-attribute attr-name (append attr-value args))))))

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