tymmym's blog

Introduction to Functional Reactive Programming with reactive-banana

2011-11-21T20:30:00.000+04:00

1. PDF of the article
2. literate Haskell source code

Введение в функциональное реактивное программирование с помощью reactive-banana

2011-11-11T00:04:00.005+04:00

Функциональное реактивное программирование (ФРП) - это метод моделирования реактивного (т.е. зависящего от времени и внешних воздействий) поведения в чистых функциональных языках. ФРП позволяет моделировать системы, реагирующие на изменяющиеся входные воздействия, в простом декларативном стиле[1].

Цель данного поста показать, как можно писать GUI на Haskell в декларативном стиле. С помощью библиотеки reactive-banana мы напишем простой счётчик, который будет управляться двумя кнопками.

Теория

Основными концепциями ФРП являются поведения (behaviors) и события (events).

Поведение - это меняющееся со временем значение. Его можно представить как:

type Behavior a = Time -> a

Событие - это поток происшествий в порядке их появления. Событие можно представить в виде бесконечного списка значений привязанных ко времени их появления:

type Event a = [(Time, a)]

Для написания программы необходимо:

получить входные поведения и события;
преобразовать входные поведения и события к нужным выходным, т.е.описать логику работы;
получить результаты от выходных событий.

Функции модуля Reactive.Banana.Implementation позволяют получать входные события и поведения от внешних источников. Например, последовательность нажатий на кнопку мыши можно представить как событие, а строку в поле ввода как значение зависящее от времени, т.е. поведение.

Функции модуля Reactive.Banana.Model позволяют описывать новые события на основе входных событий. Это описание называется графом событий. Граф событий - это своего рода описание логики работы, требуемая функциональность достигается путём комбинирования существующих событий и поведений.

Полученные путём использованием комбинаторов события выводятся с помощью функций модуля Reactive.Banana.Implementation.

Сеть событий - это граф событий вместе с входами и выходами. Для описания сети событий необходимо описать входы, выходы и граф событий в монаде NetworkDescription, а затем использовать функцию compile.

Для активации сети событий нужно использовать функцию actuate. Процесс активации заключается в регистрации входных событий и начале формирования результатов.

Практика

Начнём с импорта необходимых библиотек. Нам понадобятся:

wxHaskell для GUI,
reactive-banana для ФРП,
reactive-banana-wx для связывания wxHaskell с reactive-banana.

import Control.Monad
import Graphics.UI.WX hiding (Event)
import Reactive.Banana
import Reactive.Banana.WX

Начнём писать функцию main:

main = start $ do
f <- frame [text := "Counter"]
bup <- button f [text := "Up"]
bdown <- button f [text := "Down"]
output <- staticText f []

set f [layout := margin 10 $
column 5 [widget bup, widget bdown, widget output]]

Здесь мы создали основное окно с двумя кнопками (одна - для увеличения значения счётчика, другая - для уменьшения) и одним текстовым полем (для вывода значения счетчика).

Следующий шаг - описание сети и её компиляция для получения сети событий:

network <- compile $ do

Описание сети начинаем с определения её входов:

eup <- event0 bup command
edown <- event0 bdown command

Здесь мы использовали функцию event0 для получения событий от нажатий на кнопки. Функция |event0| предоставляется модулем Reactive.Banana.WX и служит для получения событий из wxHaskell. Т.о., если мы нажимаем на кнопки "Up" и "Down" поочереди, то мы генерируем два потока происшествий, которые можно представить как:

eup = [(time1,bupCommand),(time3,bupCommand)..]
edown = [(time2,bdownCommand),(time4,bdownCommand)..]

Следующий шаг --- описание графа событий.

Сначала мы формируем новое событие на основе входного. Используем комбинатор, который заменяет все происшествия с нажатием на кнопку на функцию |(+1)|:

let
einc :: Event (Int -> Int)
einc = (+1) <$ eup

Функция (<$) :: a -> f b -> f a заменяет все входные происшествия одинаковым значением. Результат её работы можно представить так:

(+1) <$ [(time1,bupCommand),(time3,bupCommand)..] =
[(time1,(+1)),(time3,(+1))..]

Такую же операцию проводим с событием edown, но здесь используем другую функцию - (subtract 1):

edec :: Event (Int -> Int)
edec = subtract 1 <$ edown

Объединим эти два события в одно:

ecount :: Event (Int -> Int)
ecount = einc `union` edec

Функция union объединяет два потока происшествий одинакового типа:

[(time1,(+1)),(time3,(+1))] `union` [(time2,subtract 1),(time4,subtract 1)] =
[(time1,(+1)),(time2,subtract 1),(time3,(+1)),(time4,subtract 1)]

Наконец, мы используем функцию accumD для получения меняющегося значения счётчика из события:

counter :: Discrete Int
counter = accumD 0 ecount

Полученный счётчик обладает типом Discrete, который почти идентичен типу Behavior (за описанием отличий можно обратиться документации на reactive-banana).

Функция accumD аналогична функции foldl', её можно представить как:

accumD 0 [(time1,(+1)),(time2,subtract 1),(time3,(+1))..] =
stepperD 0 [(time1,1),(time2,0),(time3,1)..]

где stepperD - возвращает функцию от времени, получая начальное значение и поток новых значений:

stepperD x0 ex = \time ->
last (x0 : [x | (timeX,x) <- ex, timeX < time])

Следующий шаг - получение результатов. Сначала мы применяем функцию show для преобразования изменяющегося значения с типом Int к типу String:

counterStr :: Discrete String
counterStr = show <$> counter

Затем используем функцию sink для отображения результатов:

sink output [text :== counterStr]

sink - вспомогательная функция с типом w -> [Prop' w] -> NetworkDescription () из модуля Reactive.Banana.WX. Она получает виджет и список элементов с типом Prop', где Prop' - это атрибут wxHaskell ассоциированный с изменяющимся значением. Ассоциация выполняется с помощью оператора (:==), имеющего тип Attr w a -> Discrete a -> Prop' w.

Заклютельный шаг - активация сети событий. Сеть регистрирует входные обработчики событий и начинает формировать результаты.

actuate network

Всё, мы написали простой счётчик в декларативном стиле.

Ссылки

Edward Amsden, A Survey of Functional Reactive Programming, 2011.
Heinrich Apfelmus, Reactive-banana API reference, http://hackage.haskell.org/package/reactive-banana
Исходный код Counter.lhs и PDF статьи.

StumpWM + Jabber.el

2009-06-29T14:49:00.013+04:00

Захотел получать оповещения о приходе в Jabber.el сообщений.Для этого сначала добавил в Jabber.el возможность отправки сообщений в StumpWM.

Создал в директории с Jabber.el файл jabber-stumpwm.el следующего содержания:
```
(eval-when-compile (require 'jabber-alert))

(defun jabber-stumpwm-message (msg)
"Show MSG in StumpWM"
;; Possible errors include not finding the stumpish (STUMPwm Interactive SHell).
(condition-case e
 (let ((process-connection-type))
(call-process "stumpish" nil 0 nil "notifications-add" msg))
(error nil)))

(define-jabber-alert stumpwm "Show a message through the StumpWM window manager"
'jabber-stumpwm-message)
```
Данный файл - копия jabber-ratpoison.el с небольшими изменениями для StumpWM. Для отправки оповещения используется STUMPwm Interactive SHell, которой в качестве аргументов передаем имя фукции оповещения и сообщение.

Добавил (require 'jabber-stumpwm) в секцию External notifiers в файле jabber.el.

Функции оповещения предоставляются модулем notifications. Для его подключения в файл ~/.stumpwmrc прописываем следующее:

(load-module "notifications")
(define-key *root-map* (kbd "N") '*notifications-map*)

А к строке *screen-mode-line-format* добавляем %N.
Результат:

Полученный результат меня до конца не устроил:
- оповещения приходится удалять вручную;
- оповещения захламляют и без того перегруженную mode-line.

Пришлось внести небольшие изменения в модуль notifications, чтобы добиться желаемого:
- добавлена возможность удаления оповещений по таймауту;
- оповещения выводятся как стандартные сообщения StumpWM.

*** notifications.lisp.old 2009-06-30 15:02:31.851810478 +0400
--- notifications.lisp 2009-06-30 15:34:10.667560769 +0400
***************
*** 75,90 ****
--- 75,107 ----
(defvar notifications nil
  "A list of notification strings.")

+ (defvar *notification-time* 20
+   "This variable controls how many seconds the notification will be
+ stored in the list of notifications. Don't use timer for
+ notification if the value is nil.")
+
+ (defvar *message-timeout* 1
+   "This variable controls how many seconds elapse between each update
+ of the message.")
+
+ (defvar *message-timer* nil
+   "The timer that updates the message.")
+
(defcommand notifications-add (str)
  ((:rest "Notification: "))
  "Add a notification string.
If a notification is already included, it will be moved to the front instead of
added anew."
+   (when *notification-time*
+     (run-notification-timer))
  (when (not (string= (car notifications) str))
    (when (member str notifications :test #'string=)
      (setf notifications (delete str notifications :test #'string=)))
    (push str notifications)))

+ (defun run-notification-timer ()
+   (run-with-timer *notification-time* nil #'notifications-delete-last))
+
(defcommand notifications-reset ()
  ()
  "Clear all notifications."
***************
*** 105,110 ****
--- 122,142 ----
  "Delete the first notification."
  (setf notifications (nreverse (cdr (nreverse notifications)))))

+ (defcommand notifications-start-messages ()
+     ()
+   "Start showing messages with notifications."
+   (setf *message-timer*
+  (run-with-timer 0
+    *message-timeout*
+    (lambda ()
+      (when notifications
+        (message-no-timeout (format nil "~{~a~^~%~}" notifications)))))))
+
+ (defcommand notifications-stop-messages ()
+     ()
+   "Stop showing messages with notifications."
+   (cancel-timer *message-timer*))
+
(defun notifications-as-string (&rest r)
  (declare (ignore r))
  (if notifications
***************
*** 126,131 ****
--- 158,165 ----
    (define-key m (kbd "d")     "notifications-delete-first")
    (define-key m (kbd "D")     "notifications-delete-last")
    (define-key m (kbd "s")     "notifications-show")
+     (define-key m (kbd "m")     "notifications-start-messages")
+     (define-key m (kbd "M")     "notifications-stop-messages")
    m))

;; Local Variables:

После выполнения функции notifications-start-messages при получении сообщений получаем следующее:

StumpWM

2009-05-15T12:31:00.024+04:00

Установил и начал настраивать под себя StumpWM - фреймовый оконный менеджер, написанный на Common Lisp. Чтобы ознакомиться с некоторыми его возможностями, можно посмотреть видео ролик.

Установка

Зависимости:

реализация Common Lisp (поддерживаются clisp и SBCL)
clx
cl-ppcre
autoconf
texinfo

Я использовал SBCL 1.0.19, пакеты clx и cl-ppcre установливал с помощью clbuild:


$ darcs get http://common-lisp.net/project/clbuild/clbuild
$ cd clbuild
clbuild$ chmod +x clbuild
clbuild$ ./clbuild install clx cl-ppcre

Чтобы asdf видел пакеты, установленные с помощью, clbuild добавим следующую строку в ~/.sbclrc:


(push #p"/path/to/clbuild/systems/" asdf:*central-registry*)

Устанавливаем последнюю версию StumpWM из репозитория:


$ git clone git://git.savannah.nongnu.org/stumpwm.git
$ cd stumpwm
stumpwm$ autoconf
stumpwm$ ./configure && make

В текущей директории появился файл stumpwm, который нужно указать в ~/.xinitrc:


$ echo "exec /path/to/stumpwm" > ~/.xinitrc
$ startx

Настройка

При запуске StumpWM использует файл ~/.stumpwmrc. Например, поместив следущие инструкции в ~/.stumpwmrc мы определим функцию, которая вызывается при нажатии C-t f. Она запускает Firefox, если он ещё не был запущен, в противном случае - переходит к ранее запущенному.

(defcommand firefox () ()
"Start/Switchto Firefox."
(run-or-raise "firefox" '(:class "Firefox")))

(define-key *root-map* (kbd "f") "firefox")

В качестве примера можно использовать файл sample-stumpwmrc.lisp, можно посмотреть на файлы .stumpwmrc других пользователей, также много инересного можно узнать из stumpwm.info.

Полностью поменять поведение StumpWM можно уже в процессе работы. Для этого можно:

внести изменения в ~/.stumpwmrc и выполнить команду С-t ; loadrc
использовать emacs и stumpwm-mode.el
использовать stumpish (STUMPwm Interactive SHell)
использовать SLIME

Использование SLIME для настройки StumpWM

Установим SLIME и создадим сивольную ссылку на stumpwm.asd для clbuild:


$ cd /path/to/clbuild
clbuild$ ./clbuild install slime
clbuild$ ln -s /path/to/stumpwm.asd systems/stumpwm.asd

Для запуска SLIME необходимо добавить в .emacs следующие строки, полученные при выполнении команды $ ./clbuild slime-configuration:


(setq load-path (cons "/path/to/clbuild/source/slime" load-path))
(setq load-path (cons "/path/to/clbuild/source/slime/contrib" load-path))
(setq slime-backend "/path/to/clbuild/.swank-loader.lisp")
(setq inhibit-splash-screen t)
(load "/path/to/clbuild/source/slime/slime")
(setq inferior-lisp-program"/path/to/clbuild/clbuild --implementation sbcl lisp")
(setq slime-use-autodoc-mode nil)
(slime-setup '(slime-fancy slime-tramp slime-asdf))
(slime-require :swank-listener-hooks)

Создадим файл startstump для запуска StumpWM и swank:


;; -*-lisp-*-
(require :stumpwm)
(require :swank)
(swank-loader::setup)
(swank:create-server :dont-close t)
(stumpwm:stumpwm)

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

Изменим ~/.xinitrc:


exec /path/to/clbuild/clbuild lisp --load /path/to/startstump

clbuild запускает реализацию Common Lisp и загружает созданный нами файл.

Выполнив startx и открыв emacs, можно выполнить команду M-x slime-connect и использовать REPL для внесения измененний. Например, следующие команды сделают стандартную mode-line более информативной:

; SLIME 2009-05-16
CL-USER> (in-package :stumpwm)
STUMPWM> (load-module "battery-portable")
T
STUMPWM> (load-module "cpu")
T
STUMPWM> (load-module "mem")
T
STUMPWM> (load-module "net")
T
STUMPWM> (setf stumpwm:*screen-mode-line-format*
            (list "%n | "
                  '(:eval (run-shell-command "date +'%a %d %b %H:%M:%S' | tr -d [:cntrl:]" t))
                  " | %l| %c| %M| %B | %W"))
("%n | "
(:EVAL (RUN-SHELL-COMMAND "date +'%a %d %b %H:%M:%S' | tr -d [:cntrl:]" T))
" | %l| %c| %M| %B | %W")
STUMPWM> (mode-line)
NIL