Как стать автором
Обновить

Io Language: Система сообщений

Ненормальное программирование *
Сегодня продолжим цикл статей, начатый достопочтенным semka. Поговорим о сообщениях.

В Ио нет вызовов функций, но есть посылка сообщений. У сообщения могут быть аргументы (почти как аргументы функции), но аргументы сообщений не выполняются перед посылкой.


Как посылают сообщения

Посылка сообщения выглядит как «объект», «пробел», «сообщение»:
Database connect

Сообщение может содержать аргументы:
Database findByName("Oleg")

Результату посылки сообщения тоже можно послать сообщение:
Database findByName("Oleg") lastName # возможно, вернет "Andreev"

Иными словами, конструкция a b c d эквивалентна a().b().c().d() в каком-нибудь джава-подобном синтаксисе.

Как выполняются сообщения

Для начала запомните, что аргументы сообщения не выполняются. Если было написано Database connect(blah-blah), то blah-blah не будет выполнено перед посылкой connect, а будет передано как часть сообщения «connect(blah-blah)» (да-да, словами).

Когда объект получает сообщение, он ищет слот с именем этого сообщения (в нашем примере connect). Если слот не найден (как обычно и происходит), его поиск осуществляется рекурсивно во всех прототипах объекта и их прототипах. Если нужный слот нигде не найден, то запускается поиск слота forward (аналог method_missing в Руби). Как только какой-нибудь подходящий слот найден, его значение активируется (activation). (Примечание: в каком же именно объекте лежит найденный слот вам расскажет Object contextWithSlot(slotName).)

Активация

Для обычных значений активация ничего не делает, в просто возвращает это самое значение. Таким образом, активация обычных слотов, хранящих числа, строки или многие другие объекты, ничем не отличается от получения значения через getSlot(slotName). А вот те объекты, которые помечены как activatable, вызывают метод activate. По-умолчанию, только два объекта активируемые: Block (блоки и методы) и CFunction (линки к сишным функциям). Все остальные объекты можно сделать активируемыми с помощью setIsActivatable(true).

Активация слота не происходит при вызове метода getSlot(slotName) (разумеется, сам слот «getSlot» активируется, а вот slotName — уже нет). Поэтому, если вы хотите получить метод или блок as-is, не вызывая его, то пользуйтесь getSlot(methodName).

С активацией связан один подводный камень, о котором пойдет речь в конце статьи.

Эээ. А когда аргументы выполняются-то?

Сообщение послано, слот найден и активирован. Но когда и в каком контексте будут вычислены аргументы сообщения?

Рассмотрим пример:
withoutArgs := method() # метод возвращает nil
withoutArgs("Hello!" println)

Этот код ничего не выведет потому что аргумент «Hello!» println не был выполнен.
withArgs := method(a, b, c, list(a,b,c)) # метод возвращает список аргументов
withArgs("Hello!" println) # возвращает list("Hello!", nil, nil)

Этот код выполнит первый аргумент и выведет на экран Hello!. Недостающие аргументы будут равны nil.

Еще один пример:
withTwoArgs := method(a, b, nil)
withTwoArgs(1 print, 2 print, 3 print, 4 print)

Этот код напечатает 12, но не 1234.

Самые догадливые уже поняли, что выполняются только объявленные аргументы. Самое забавное — это то, как они выполняются, где и куда можно запустить свои грязные руки. И зачем все это нужно.

Интроспекция вызова метода

Вы еще помните, что в Ио есть только объекты, прототипы, слоты и сообщения? Глобальных и локальных переменных в этом списке нет.

Когда Ио активирует слот (сиречь вызывает метод), он создает специальный объект Locals. Это довольно забавный объект, имеющий ряд важных особенностей. Во-первых, прототип этого объекта — self, т.е. указатель на тот объект, которому послано сообщение. Таким образом, мы можем создавать локальные слоты (aka локальные переменные), не вмешиваясь в объект-получатель, а также получить доступ ко всем слотам этого объекта. Во-вторых, в этом объекте есть как минимум три слота: self (указывает на объект-получатель), call (содержит массу информации о вызове) и updateSlot. Последний отличается от обычного updateSlot тем, что обновляет слот не в locals, а в объекте-получателе. Это сделано исключительно удобства ради, чтобы писать a = b вместо self a = b.

Самое замечательное в объекте call — это несколько слотов:
  • call sender — объект (locals), в котором было послано сообщение.
    call target — объект, которому было послано сообщение (== self).
    call message — собственно, сообщение, содержащее имя и аргументы.
    call evalArgAt(argNumber) и evalArgs выполняют некоторый или все аргументы в контексте сендера (call sender). Но никто не мешает сделать что-нибудь такое:
    Object do := method(call message arguments first doInContext(self) )
    "string" do(
    type println
    size println
    encoding println
    )

    На экране мы увидим:
    Sequence
    6
    ascii


    Иными словами, мы можем манипулировать кодом как нам угодно: передавать, хранить, выполнять в произвольных контекстах. Можно посмотреть код уже созданного объекта: Coroutine getSlot(«yield») code вернет код метода yield в виде строки:
    method(
    if(yieldingCoros isEmpty, return )
    yieldingCoros append(self)
    next := yieldingCoros removeFirst
    if(next == self, return )
    if(next, next resume)
    )


    Кстати, про прототип locals я приврал. Если вы еще помните, кроме методов в Ио есть блоки (замыкания). Их единственное отличие от методов состоит в том, что прототип Locals у блоков не указатель на получатель сообщения, а указатель на scope, т.е. тот объект, в котором блок был создан (и на который он замкнут). Чтобы у вас окончательно уехала крыша, добавлю, что слот блока scope в точности равен call sender в момент вызова метода block.

    Обратно к локальным переменным

    Обладая столь мощным оружием, как call sender и call message, мы можем описать вызов метода и выполнение аргументов на языке Ио. Действительно, говоря method(a, b, nil), мы сообщаем, что хотим создавать слоты «a» и «b» в locals и заполнять их значениями, которые получены после выполнения соответствующих аргументов в контексте call sender. Домашнее задание: написать метод method2, который создает методы так же, как и встроенный method и проделывает все необходимые манипуляции с doInContext для объявленных и переданных аргументов.

    Обещанная уловка с активацией

    В джава-подобном синтаксисе доступ к функции и её вызов выглядят так: obj.func и obj.func(). В Ио получение значения без активации возможно через obj getSlot(«slot»), когда obj slot обязательно активирует значение слота.

    Предположим, вы пишите метод, который может принимать другой метод в качестве аргумента:
    method(func, ...)

    Если вы напишите func внутри тела метода, то вы неминуемо вызовете переданный метод. Если вам нужно просто получить его значение, то вам придется каждый раз обращаться к нему через getSlot(«func»).

    Конструирование сообщений

    Метод message возвращает свой первый аргумент как невыполненное сообщение:
    msg := message(something(arg1, arg2, arg3) nextMessage(arg1, arg2) more)
    msg name # => "something"
    msg next # => message(nextMessage(arg1, arg2) more)
    msg next next # => message(more)
    msg next name # => "nextMessage"
    msg arguments # => list(message(arg1), message(arg2), message(arg3))


    Резюме

    Теперь вы знаете как происходит посылка сообщений, вызов методов и выполнение аргументов. Надеюсь, вам стали понятны конструкции типа list(1,2,3) foreach(print) (print посылается каждому элементу списка) или list(1,2,3) map(*2) (каждому элементу посылается *(2) при создании копии списка).

    Bonus track: call sites

    Полтора землекопа, которые дочитали до конца статьи могут быть вознаграждены особо восхитительной информацией. В концепции Ио возможно достучаться то так называемой «точки вызова». Это не колстек, не контекст aka «call sender», а именно точка кода, в которой произошел вызов. Все дело в том, что call message всегда возвращает один и тот же объект, если он не сгенерирован на лету, а описан в коде (ну, или сгенерирован один раз и все время посылается). Что это дает? Поскольку один метод может обрабатывать разнообразные сообщения (в разных местах программы), становится возможным закешировать что-нибудь полезное в релевантных местах.

    Самое простое: Message setCachedResult(res) устанавливает вычисленное значение сообщения, которое будет возвращаться при попытке послать это сообщение куда-либо. Более сложный вариант: кешировать специальную логику, адаптированную под конкретное сообщение в данной точке вызова.

    Например, у метода List map есть три реализации: с одним, двумя и тремя аргументами. В текущей реализации проверка количества аргументов происходит при каждом вызове, хотя возможно закешировать нужный вариант метода в call message.
    На основе этой функциональности возможно построение более сложных схем оптимизации.
Теги: Iooopmessagesсообщенияооп
Хабы: Ненормальное программирование
Всего голосов 27: ↑27 и ↓0 +27
Комментарии 20
Комментарии Комментарии 20

Похожие публикации

Лучшие публикации за сутки