Показаны сообщения с ярлыком макросы. Показать все сообщения
Показаны сообщения с ярлыком макросы. Показать все сообщения

пятница, 4 февраля 2011 г.

За что мне не нравится Java. Паттерны проектирования.


Вообще, если брать отдельно от Java и прочих таких же ограниченных языков, паттерны – хороший инструмент. Они позволяют не изобретать велосипед, а реализовывать проверенные временем фрагменты архитектуры. Проблема Java (а также C#, C++ и т. д.) в том, что все эти паттерны приходится писать богомерзким copy-paste-ом, т. к. ни реализовать их в виде библиотеки, ни ввести в синтаксис языка — невозможно.
Другое дело – Clojure. Здесь я буду приводить пример декоратора с одним методом для простоты демонстрации. Вот как я себе представляю DSL и использование его для реализации этого паттерна.

(ns jv
(:import (deco Decorable)))

(gen-deco "jv.My2" (println "Hello from jv.My2"))
(gen-deco "jv.My3" (println "Hello from jv.My3"))

Здесь генерируются два декоратора в пространстве имен jv. Скомпилировать их можно вызовом (compile 'jv), и clojure создаст два класса My2 и My3.

user=> (compile 'jv)
jv

Использовать декораторы можно так. Откроем скомпилированное пространство имен jv.

user=> (in-ns 'jv)
#<Namespace jv>

Создадим декорируемый элемент.

jv=> (def a (decorable))
#'jv/a

Его метод run выводит строку:

jv=> (.run a)
Hello from Decorable!
nil

Аналогично для классов My2 и My3.

jv=> (def b (jv.My2.))
#'jv/b
jv=> (.run b)
Hello from jv.My2
nil
jv=> (def c (jv.My3.))
#'jv/c
jv=> (.run c)
Hello from jv.My3
nil 

Теперь используем динамическую композицию объектов и декорируем объект а функциональностью объекта b.

jv=> (decorate b a)
nil
jv=> (.run b)
Hello from jv.My2
Hello from Decorable!
nil

Теперь динамически добавим функциональность объекта c.

jv=> (decorate c b)
nil
jv=> (.run c)
Hello from jv.My3
Hello from jv.My2
Hello from Decorable!

Как видите, создание и использование паттерна декоратор ограничилось всего тремя синтаксическими конструкциями: gen-deco, decorable, decorate.
Базовый класс deco.Decorable выглядит так.

package deco;
public class Decorable {
private Decorable deco;

public void run() {
System.out.println("Hello from Decorable!");
}

public Decorable getDeco() {
return deco;
}

public void setDeco(Decorable deco) {
this.deco = deco;
}
}

Макросы, реализующие паттерн «декоратор» – ниже.

(defmacro deco-class [new-name old-name method body & params]
  (let [this (symbol "this")
         prefix (gensym)
         new-method (symbol (str prefix method))
         call-method (symbol (str "." method))]
  `(do
     (defn ~new-method [~this ~@params]
      ~body
        (let [deco# (.getDeco ~this)]
            (if (not (nil? deco#))
                (~call-method deco# ~@params))))

        (gen-class
          :name ~new-name
          :prefix ~prefix
          :extends ~old-name))))

(defn decorate [new-obj old-obj]
   (.setDeco new-obj old-obj))

(defn decorable []
   (deco.Decorable.))

(defmacro gen-deco [name body & params]
  (let [run (symbol "run") ]
      (if (nil? params)
       `(deco-class ~name deco.Decorable ~run ~body)
       `(deco-class ~name deco.Decorable ~run ~body ~params))))

Таким образом, Clojure – язык, который позволяет не плодит ужасающий copy-paste для реализации паттернов, а разработать высокоуровневую абстракцию и автоматизировать все повторяющиеся фрагменты.

понедельник, 31 января 2011 г.

Hotpatch и декораторы


В продолжение анафорических макросов из On Lisp прочел эту же тему в Let Over Lambda Дуга Хойте. Там рассматривается несколько интересных приемов применения анафор, но самое любопытное, что я нашел, – это hotpatch.
Идея заключается в том, что некоторое лямбда-выражение может динамически менять содержимое своей функции. Таким образом, «апдейт» получат одновременно все, кто ее использует.
Идея использования:

(def my (hotpatch [a] (println a)))

Здесь создается анонимная функция, которая печатает свой аргумент; функция связывается с именем my. Теперь к ней можно обращаться так:

(my 11)

Clojure напечатает 11. Теперь заменим динамически содержимое функции.

(my :hotpatch (fn [] (println "Hello world!")))

После такой замены вызов (my) напечатает «Hello world!».

Макрос hotpatch выглядит так.

(defmacro hotpatch [& body]
   `(let [my-fn# (ref (fn ~@body))]
       (fn [& params#]
         (if (and (not (nil? params#))
                      (> (count params#) 1)
                      (= :hotpatch (first params#)))
            (dosync (ref-set my-fn# (second params#)))
            (apply (deref my-fn#) params#))))

А теперь самое интересное. Добавим в макрос hotpatch возможность возвращать текущую функцию.

(defmacro hotpatch [& body]
   `(let [my-fn# (ref (fn ~@body))]
       (fn [& params#]
          (if (and (not (nil? params#))
                       (= (count params#) 1)
                       (= (first params#) :fn))
               @my-fn#
               (if (and (not (nil? params#))
                            (> (count params#) 1)
                            (= :hotpatch (first params#)))
                    (dosync (ref-set my-fn# (second params#)))
                    (apply (deref my-fn#) params#))))))

Теперь содержимое функции можно вызвать так: ((my :fn))

Вот как с помощью этого макроса реализуется знаменитый паттерн «декоратор»:

(let [old (my :fn)]
(my :hotpatch (fn [] (println "New func") (old))))

По сути и паттерна-то никакого нет, просто функция заменяет свое значение на новое, вызывая в конце старое.

(my)

New func
Hello world!

Таким образом, макрос сильно упрощает использование идиоматичных конструкций.

воскресенье, 30 января 2011 г.

Анафорические макросы на Clojure


Во все той же незабвенной «On Lisp» Пола Грэма в главе 14 рассматривается такое понятие, как анафорический макрос. Анафора в естественном языке – термин, означающий ссылку на что-то в предшествующем разговоре. В языке программирования анафора – отсылка к предыдущим результатам вычислений. Например.

(defn my-long-calculation [param] param)

(aif (my-long-calculation 15)
   (println result)
   (println "The result is nil!")

Здесь aif – анафорический if, который результат вычисления функции my-long-calculation присвоит переменной result. Соответственно, result здесь – это анафора, которая ссылается на результат вычислений. Кроме того, ветка then здесь будет выполнена только в случае, когда result не равен nil, иначе управление перейдет ветке else.
Забавный, в общем макрос. Тем более, что, обратите внимание, пользователь переменную result не создает, это делает за пользователя макрос aif. Но в Clojure его нет, и нам предстоит его написать.
Проблема в том, что в Clojure захват лексической привязки result – очень неидиоматичное решение. Мне даже не удалось найти стандартного способа это сделать. Например.

(defmacro a [body]
   `(let [b 15]
      ~@body))

(a (println b))

Здесь Clojure создаст исключение «Can't let qualified name: user/b». Можно, конечно, воспользоваться gensym:

(defmacro a [body]
   (let [b (gensym "b")]
     `(let [~b 15]
       ~@body)))

(a (println b))

Здесь ошибка уже «Unable to resolve symbol: b in this context», потому что gensym генерирует уникальное имя во избежание захвата переменной (variable capture).
Создадим свою версию gensym, результатом которой было бы предсказуемое имя переменной.

(defn make-sym [name] (. clojure.lang.Symbol (intern (str name))))

Теперь можно написать анафорический макрос aif.

(defmacro aif
  ([expr then]
     (let [result (make-sym "result")]
       `(let [~result ~expr]
           (if (not (nil? ~result))
            ~then))))
  ([expr then else]
     (let [result (make-sym "result")]
      `(let [~result ~expr]
          (if (not (nil? ~result))
           ~then
           ~else)))))

Одним словом, анафорические макросы в Clojure писать так же легко, как и любые другие.

среда, 26 января 2011 г.

За что мне не нравится Java. Проверки на null


Хотя сам занимаюсь разработкой на Java, язык этот мне кажется чересчур громоздким и многословным. Много в нем недостатков, но сегодня коснусь одного, уж очень сильно раздражающего.
При вызове методов постоянно нужно следить за null-ами. Написал метод – будь добр, проверь все параметры на null. Вызвал метод – проверь полученное значение на null. Делать это нужно постоянно, а исходник страдает обилием проверок, здорово захламляющих логику.
В отличие от Java, язык Clojure, наследник Lisp-а, позволяет изменять собственный синтаксис. Главная фишка Clojure – макросы и программирование на уровне абстрактного синтаксического дерева. Воспользуемся этими вкусностями и автоматизируем проверку на null всех параметров функции.

(defn nil-parameter [f] (println "One of the parameters of the function" f "is nil!"))

(defmacro defn-checked [name parameters & body]
   `(defn ~name ~parameters
      (if (or ~@(map (fn [p] `(nil? ~p)) parameters) )
        (nil-parameter (str ~name))
        (do ~@body ))))

Теперь можно создать функцию при помощи новой синтаксической конструкции defn-checked также, как и при помощи defn.

(defn-checked my [p1 p2] (println "123"))

На стадии компиляции исходника Clojure преобразует этот код в следующий.

(defn my [p1 p2]
   (if (or (nil? p1) (nil? p2))
     (nil-parameter (str my))
       (do
         (println "123"))))

Чуть сложнее делать проверки возвращаемых значений. Показанный ниже макрос использует возможности программирования на АСТ для преобразования списка bindings.

(defn nil-value [] (println "One of the values is nil!"))

(defmacro let-checked [bindings & body]
   (let [indexed-bindings (map vector (iterate inc 0) bindings)
          symbols (map #(second %) (filter #(even? (first %)) indexed-bindings))
          values (map #(second %) (filter #(odd? (first %)) indexed-bindings))
          results (gensym "results")
          indexed-symbols (map vector symbols (iterate inc 0))]
          `(let [~results ~(vec values)]
              (if (not (empty? (filter #(nil? %) ~results)))
                (nil-value)
                (let [~@(reduce join 
                                          (map (fn [s] [(first s) 
                                                   `(nth ~results ~(second s))]) indexed-symbols))]
                ~@body)))))

Теперь можем использовать новую конструкцию let-checked также, как и let:

(let-checked [a 5
                    b (+ 1 2)]
  (+ a b))

На стадии раскрытия макросов Clojure создаст следующий код.

(let [results [5 (+ 1 2)]]
   (if (not (empty? (filter (fn [p] (nil? p)) results)))
     (nil-value)
     (let [a (nth results 0)
            b (nth results 1)]
       (+ a b))))

Как видите, вначале будут вычислены все значения и занесены в вектор results. Затем произойдет проверка, есть ли хоть один null среди значений results. И только если все значения не равны null, произойдет привязка новых символов a и b к элементам вектора results, и будет выполнено тело выражения.
А ваш язык программирования может такое?

пятница, 21 января 2011 г.

Когда нужны макросы


В 8-й главе книги «On Lisp» Пол Грэм рассуждает о том, когда и почему нужно использовать макросы, а не функции. Два пункта интуитивно понятны: вычисление условных выражений и множественные вычисления. Они позволяют создавать конструкции условных переходов и циклы.
Но для меня наиболее интересными представляются следующие случаи: создание лексического окружения и трансформация кода. Рассмотрим их на примере простого DSL.
Предположим, необходимо дополнить язык Clojure синтаксическим конструкциями для описания интерфейса пользователя. То, что обычно делают графические рисовалки интерфейсов в монстрозных IDE, нужно выразить в виде такого кода:

(defn pushme [] (println "You have pushed the button!")) 

(create-window mywin
  (label mylabel "Test label")
  (button mybutton "Pushme!" pushme))

После выполнения этого кода необходимо, чтобы была доступна привязка mywin, которая содержит map со всеми свойствами будущего окна. Вот пример макросов, которые позволяют это реализовать.

(defmacro create-window [name & funcs]
   `(def ~name
      (let [my-win# {:name ~(str name)}]
         (-> my-win# ~@funcs)))) 

(defmacro label [win name title]
  `(assoc (assoc ~win
     ~(keyword (str name "-type")) "label")
     ~(keyword (str name "-title")) ~title))

(defmacro button [win name title action]
  `(assoc (assoc (assoc ~win
    ~(keyword (str name "-type")) "button")
    ~(keyword (str name "-title")) ~title)
    ~(keyword (str name "-action")) ~action))

Как видно из кода, здесь активно используется возможность создания ключевых слов для map-а при помощи конструкции (keyword (str name «-something»)). Параметр name передается в виде обыкновенного символа Clojure; перед ним не надо ставить двоеточие или заключать его в кавычки. Такая трансформация name-а возможна потому, что макрос принимает свои аргументы «как есть», не вычисляя их. Поэтому неважно, что символ name не только ни к чему не привязан, но даже и не объявлен.
Удобным инструментом для создания фрагментов DSL является функция ->. Она позволяет перенаправлять выход одной функции на вход другой первым аргументом. Таким образом, легко строить декораторы функций. Свойства окна удобно перечислить «в столбик», а декоратор вызовет последовательно все заданные функции. Например:

(defn ok-pushed [] (println "You have pushed the OK button!"))
(defn cancel-pushed [] (println "You have pushed the Cancel button!"))

(create-window mywin
   (label confirmation "Do you really want to delete the selected files?")
   (button ok-button "OK" ok-pushed)
   (button cancel-button "Cancel" cancel-pushed))

Созданный map выглядит так.

user=> mywin
{:cancel-button-action #<user$cancel_pushed user$cancel_pushed@2c17f7>, :cancel-button-title "Cancel", :cancel-button-type "button", :ok-button-action #<user$ok_pushed user$ok_pushed@33788d>, :ok-button-title "OK", :ok-button-type "button", :confirmation-title "Do you really want to delete selected files?", :confirmation-type "label", :name "mywin"}

Теперь можно даже «нажать» на кнопку.

user=> ((:cancel-button-action mywin))
You have pushed the Cancel button!

Подводя итоги, могу сказать, что макрос – незаменимый инструмент для трансформации кода. Особенно полезным считаю то, что эта трансформация происходит во время компиляции программы, а не во время исполнения. Тормоза во втором случае известны всем любителям ruby и python.

Инкапсуляция на Clojure


Как-то давно, почитывая SICP , наткнулся на интересный способ использования лексических замыканий. Поскольку при определении функции в Scheme несвязанные переменные сохраняются, то можно вывести функции cons, car и cdr следующим образом: 

(define (cons x y)
  (define (dispatch m)
    (cond 
      ((= m 0) x)
      ((= m 1) y)))
    dispatch)
(define (car z) (z 0))
(define (cdr z) (z 1)) 



Здесь cons – это функция, которая возвращает не списочную структуру, а другую функцию (dispatch), в которой x и y – несвязанные переменные, сохраненные в ее контексте. Функция dispatch возвращает либо x, либо y в зависимости от значения своего аргумента.
Этот учебный пример, конечно же, очень простой. А как много вообще можно инкапсулировать внутри одной функции?
Чисто из спортивного интереса решил реализовать на Clojure инкапсуляцию данных и методов их обработки так, как это делается в ООП.

(defmacro create-class [name funcs]
   (let [obj (symbol (str "create-" name))
          state (gensym "state")
          msg-sym (gensym "msg")
          params-sym (gensym "params")
          props (gensym "props")]
   `(defn ~obj [~props]
     (let [~state (reduce #(conj %1 [(first %2) (last %2)]) {} ~props)]
       (fn [~msg-sym &~params-sym]
         (cond
          ~@(apply concat (for [f funcs]
               [`(= ~msg-sym ~(first f))
              `(apply ~(second f) ~state ~params-sym)]))
            (= ~msg-sym :get) ((first ~params-sym) ~state)
            (= ~msg-sym :set) (~obj (assoc ~state (first ~params-sym) (second ~params-sym)))))))))

Макрос create-class принимает на вход имя класса, а также список названий методов класса и соответствующих им функций. После раскрытия макроса Clojure создаст функцию create-<имя-класса>, которая принимает список свойств объекта и их значений, а вернет функцию-диспетчер, отвечающую за передачу сообщений нужным функциям.
Предположим, мы хотим создать класс rectangle с двумя методами, вычисляющими площадь и периметр прямоугольника.

(defn square [self]
   (* (:width self) (:height self))) 

(defn perimeter [self]
   (+ (* 2 (:width self)) (* 2 (:height self))))

Эти методы принимают map, в котором должны быть определены значения для ключей :width и :height.
Создаем класс, который содержит эти методы.

(create-class my-square [[:square square] [:perimeter perimeter]])

Создаем объект, проинициализировав его свойства :width и :height.

(def my-rect (create-my-square [[:width 4] [:height 5]]))

Технически, my-rect – это функция-диспетчер, которая знает кому какое сообщение передать. Она хранит в своем контексте состояние объекта в виде map-а, который и передает первым параметром в каждый вызываемый метод. Например, так:

user=> (my-rect :square)
20
user=> (my-rect :perimeter)
18

Еще в этой функции определены аксессоры к свойствам объекта.

user=> (my-rect :get :width)
4
user=> (my-rect :get :height)
5

Операция установки значения свойства объекта не изменит объект, а вернет его копию с измененным значением.

user=> (def my-rect2 (my-rect :set :height 10))
#'user/my-rect2
user=> (my-rect2 :get :height)
10
user=> (my-rect :get :height)
5
user=> (my-rect2 :square)
40

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