Лямбда - функциональное программирование

ru_lambda @ 2012-05-28T17:47:00

2012-05-28T14:48:00Z

Есть у меня некие типы данных, условно говоря, такие

data T1 = Q | B String | R | ........
data T2 = Left | Right | Potato Int | .....
data TT = TT T1 T2

Нужен мне для работы тип ТТ, но в силу специфики предметной области в 99% процентов случаев это будет одна из 20-30 комбинаций, поэтому мне удобно завести функции вида

f1 = TT Q Left
f2 = TT Q (Potato 7)
f3 = TT R Right
...
f20 = TT (B "Last One") (Potato 0)

чтобы количество текста сократить, тем более, что все эти f1 - f20 - устоявшиеся и всем известные названия; кроме того хочется мне при обработке типа ТТ повторно их использовать, чтобы не писать вновь 20 раз

process (TT Q Left) = ...
process (TT Q (Potato 7)) = ...
process (TT R Right) = ...
...
process (TT (B "Last One") (Potato 0))) = ...
process (TT a b) = universalProcessing a b

а иметь нечто в духе

process (id -> f1) = ...
process (id -> f2) = ...
process (id -> f3) = ...

и так далее.

Как такое можно сделать?

Coq.

2012-05-13T07:11:13Z

Как доказать в Coq 1<=0 -> False?

Курочки невидимки

2012-04-28T10:34:10Z

читаю Fun with type functions; Oleg Kislov, SPJ
дошел до раздела про мемоизацию, не совсем понял как она работает и стал проверять на примерчике

class Memo a where
data Table a :: * -> *
toTable :: (a -> w) -> Table a w
fromTable :: Table a w -> (a -> w)

instance Memo Bool where
data Table Bool w = TBool w w deriving Show
toTable f = TBool (f True) (f False)
fromTable (TBool x y) b = if b then x else y

fact 0 = 1
fact n = n* fact (n-1)

f :: Bool -> Int
f True = fact 10008
f False = fact 100

g :: Bool -> Int
g = fromTable ( toTable f)

gg = g True + g True

выполняем gg и получаем 0

у меня два вопроса
1) если закомментарить определение типа для f и g, то gg выдаст результат отличный от нуля. А если раскомментарить = 0.
Почему?
2) Авторы утверждают что gg выполнится в 2 раза быстрее, чем f True + f True. С чего бы это? я не вижу где кэширется результат выполнения g первый раз

Вышел русский перевод книги "Learn You a Haskell for Great Good!"

2012-04-04T06:58:00Z

В русском переводе книга называется "Изучай Haskell во имя добра!". Если кто-нибудь не в курсе, это замечательный учебник по Haskell, лучше вы скорее всего нигде не найдете, тем более в печатном варианте и на русском языке.

Заказ можно оформить тут: http://www.dmk-press.ru/catalog/computer/prog_lang/izuchay_haskell_vo_imya_dobra/ или на Озоне. На Озоне говорится, что книга поступит 13-го апреля. Цена - 389 рублей.

Безусловный интерпретатор LISP на LISP

2012-02-27T08:32:46Z

Здравствуйте!

У меня возникла задача, которую можно сформулировать целиком в терминах языка LISP.

Требуется найти такие функции encode, decode и reduce, что

(decode (reduce … (reduce (encode (quote expr))) … ))

для некоторого конечного количества применений reduce является результатом интерпретации выражения expr, в котором можно ограничиться переменными и lambda одного аргумента, причем возвращаемое значение encode — это рекурсивное S-выражение memory с циклами без атомов, а функция reduce должна иметь следующий вид:

(lambda (memory)
	(set (c[ad]*r memory) (c[ad]*r memory))
	(set (c[ad]*r memory) (c[ad]*r memory))

	…

	(set (c[ad]*r memory) (c[ad]*r memory))

	memory
)

Был бы признателен за помощь в решении данной задачи.

Заранее спасибо.

Парсеры для Ur/Web.

2012-02-13T11:57:40Z

А как на Ur строки парсить можно?

(По идее, pure комбинаторы на Окамле могут скомпилироваться почти без изменений, но вроде всё виденное на Окамле использует ссылки и мутабельность.)

Haskell+web

2012-02-04T07:32:08Z

Товарищи писатели вебни на хаскеле! Здесь же есть такие?

Мне нужно (для личных нужд) написать веб-приложение на хаскеле, работающее с базой. Будут храниться блобы (0.2-5 Мб) с описанием в базе (да, именно в базе, а не в файловой системе) и раздаваться авторизованным пользователям. Плюс интерфейс загрузки - отдачи, плюс контроль прав.

Существо я исключительно ленивое, поэтому чем проще в использовании будет решение, тем лучше. Какие решения вы посоветуете? А то пока я подумываю о написании CGI приложения в лоб, т.е. без сторонних библиотек, но это как-то не комильфо.

quick check & test data generator

2012-01-27T00:50:41Z

привет, вопрос такого порядка - у меня есть несколько файлов, из которых построчно надо считать данные и сложить их в списки (скажем 5 списков)

дальше по этим спискам надо нагенерить комбинаций по 5 - выбрать случайный элемент из каждого списка и получить кортеж

курение документации и примеров по quickcheck не позволило ответить на вопрос - как передать в class Arbitrary Cortege списки, прочитанные из файла?

пока варианты - записать списки в IORef, а внутри arbitrary через unsafeIO их читать, но это какой-то аццкий хак получается.

как правильно?

case x of

2012-01-22T21:46:31Z

В тренировочных целях пишу парсер простенького бинарного формата и столкнулся с не очевидным, для меня, поведением.
Я побитово читаю данные и перевожу автомат между состояниями: parse :: Word8->ParseState->ParseState
и получении некотрых конкретных значений - я меняю состояние.

Сами эти значения я записал заранее:

data State = S1|S2|S3

b1 = 123
b2 = 213

parse b s = case (b, s) of
        (b1, S1) -> S2
        (_ , S1) -> S3
        (b2, S2) -> S1

При этом оказывается что

(parse 2 S1) = S2

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

[F#] Скрестить комбинаторы с FsYacc

2012-01-18T14:38:52Z

Имеется парсер на комбинаторах. Предположим что восстановить грамматику из комбинаторов мы можем. Хочется (автоматически) заменить код на комбинаторах на вызов FsYacc.

Проблема: Парсер комбинаторы парсят потоки Char а FsYacc хочет полноценный лексер (lexbuf и функцию из lexbuf в токены)
Возможное решение: навелосипедить свою библитеку комбинаторов, где она будет принимать что-то лексероподобное, но посложнее чем просто поток символов.
Ещё возможное решение: Оставить поток сиволов как есть, а некоторые парсер функции считать кусками лексера и превращать в регулярки, например. Т.е. из комбинаторов генерить свой лексер.

Лично мне первое какжется по-проще.

А вы бы как сделали?

P.S. Чуть по-конкретнее, ибо меня уже завалили вопросами.
На входе: дотнетовский класс, где методы --- это парсер-функции (т.е. имеют тип _ -> result)
На выходе: дотнетовский класс, где вызовы некоторых методов подменены на вызовы fsyacc (Но типы те же и снаружи кажется, что ничего не поменялось)

Здесь "некоторые методы" это методы, которые программист захотел сделать на fslex.
Основные грабли: fsyacc ходит парой с fslex. А комбинаторы обычно парсят сразу поток сиволов (без токенизации, т.е. им лексер не нужен)
Т.е. надо или как-то навелосипедить свои комбинаторы которые принимают не поток символов, а что-то лексеро-подобное. Либо из кода комбинаторов получать тем или иным образом информацию о лексере и генерить кроме кода на fsyacc код для fslex (что-то звучит страшновато)

Надеюсь что-то прояснилось.

Вопросы новичка.

2012-01-17T13:27:54Z

Продолжаю освоение хаскеля.

Вот функция, покомпонентно преобразующая rgb цвет из Double в Word8

type ColorF = (Double, Double, Double)
type ColorB = (Word8, Word8, Word8)

f2b:: ColorF->ColorB
f2b (r,g,b) = (p r, p g, p b)
               where p = round . (*255)
               where p x = round $ x*255

1) Какой из вариантов where предпочтительнее?
2) Мне не нравится запись (p r, p g, p b), так и хочется сделать аналог map для коржей. Это правильное желание?
3) Я правильно понимаю, что если хочу производительности на изображениях ([ColorB])то мне нужны ByteString и придется отказаться от удобных типов в угоду производительности?

Haskell - State ( IO ) или IO ( State )?

2012-01-16T15:02:19Z

Разбираюсь тут в монаде State. Возник вопрос - а как бы ее поудобнее использовать вместе с монадой IO? Например, если я хочу не только состояние, но и использовать System.Random.

Вот что мне удалось набросать самому:
а) Используем только монаду State, при этом храним в состоянии генератор типа StdGen
б) Монада IO, вложенная в монаду State
в) Монада State, вложенная в монаду IO

В общем-то, все эти способы кажутся рабочими, но от них просто разит топорностью.

Вопрос - как "правильно" такие вещи делаются в Haskell?

Ну и пользуясь случаем - может кто-нибудь показать пример работы с type IntState a = State Int a, то бишь без структур? Не могу понять, как в этом случае считать/записать состояние. С этим я разобрался благодаря aaknop

UPD: Всем спасибо за помощь, вроде во всем разобрался.

attoparsec и передача состояния.

2011-12-29T12:25:21Z

Всем доброго дня.

Возник вот такой (вероятнее всего тупой) вопрос. Собрался я написать парсер одного бинарного формата. Выбор либы пал на attoparsec, который вроде бы для этого как раз и предназначен. Непонятно вот что. Как передать состояние внутрь парсера? Например в процессе парсинга находится какое-либо значение, которое потом нужно использовать чтобы разобрать следующий кусок данных (в другом парсере разумеется).

Перевод статьи "The equation of finding top-notch programmers to a bootstrapped start-up..."

2011-12-27T06:41:43Z

"С точки зрения спроса я понял: никто не использует программистов Haskell. Таким образом, я пришел к выводу: здесь налицо избыточное предложение при нехватке спроса. Такая ситуация неминуемо должна привести к уменьшению цен, и, запуская новый проект, мы в самом деле сможем позволить себе нанять этих первоклассных программистов"

Тут: http://thesz.livejournal.com/1291235.html эта статья немного обсуждалась. Возможно, вам будет интересно ознакомиться с ее переводом: http://it-talk.org/topic2825.html

Генерация грамматик по парсер-комбинаторам

2011-12-16T11:16:03Z

Мне тут поставили задачу: к весне сделать какую-то либу на F#, чтобы человек писал парсер-комбинаторные функции, а тула на основе этих функций бы генерировала парсер, который работает не комбинаторами a LALR, GLR, рекурсивный спуск и т.п. Разрешается туле не определять во что генерить каждый комбинатор, пускай человек подсказывает ей во что генерить. Код, который генерит парсер того или иного типа на основе определенной грамматике уже есть.

Вопрос: на сколько я вляпался и не стоит ли мне слиться заранее? Честно, я примерно понимаю как комбинаторы работают, но пока я с ними на Вы. Люди говорят, что задача не особо интересная, так как генерить из комбинаторов грамматику обычно не нужно вообще.

Спасибо, что мне подсказали про ссылку thedeemon'a? Теперь я примерно знаю как на камле генерить из комбинаторов конечные автоматы.

Хочу вначале осмыслить концептуально как это должно выглядеть. Комментарии приветствуются.

Работа программистом-контрактором.

2011-12-16T08:39:49Z

Стартап под названием Parallel Scientific ищет опытных программистов-контрактников для работы над высокопроизводительными вычислениями (high performance computing).

Я узнал о них из Haskell-Cafe, где их рекомендовал сам SPJ. Кстати, руководители стартапа и Саймон довольно плотно общаются, насколько я понял.

Хорошее знание Хаскеля обязательно. Основная задача - создание библиотек и оптимизаций компилятора (работа одного из первых участников компании) для ускорения работы научных и коммерческих вычислений на многопроцессорных машинах и кластерах.

Я подчеркну, что Parallel Scientific уже имеет достаточный объём инвестиций (ранний этап, но уже инвестирован - early stages but funded). Это означает, что заработная плата будет весьма достойной - на уровне оплаты труда хороших программистов в США, но при возможности удалённой работы.

Если всё это заинтересовало, то ваше резюме ждут на jobs@parsci.com.

ru_lambda @ 2011-12-12T17:35:00

2011-12-12T16:35:41Z

коллеги,

"Типы в языках программирования" в количестве 10 экземпляров поступили в магазин МЦНМО (адрес тут: http://ru-lambda.livejournal.com/133077.html).

Также по-прежнему действует предложение "Книга-почтой" из того же урла.

Я очень ищу контакты распространителей в крупных городах - Санкт-Петербург, Новосибирск, Екатеринбург (или не столь крупных). От магазинчика требуется находиться в более-менее удобном месте и быть готовым купить или взять на реализацию какое-то разумное количество порядка десятка и добирать по необходимости. Пишите на squadette@gmail.com.

P.S.: я надеюсь, что еще несколько постов на эту тему с интервалом в пару недель сообщество выдержит. Если нет — извините, я перестану!

Code review

2011-11-28T14:48:26Z

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

Вот первое детище: https://gist.github.com/1400214 - работать то работает, но хотелось бы получить комментарии по стилю написания и потенциальным ошибкам.

Делает следующее: читает список номеров из файла, делает по каждому номеру запрос, строит частотный словарь ответов.

"Типы в языках программирования", бумажная книга

2011-11-27T20:23:16Z

коллеги,

книгу "Типы в языках программирования" можно купить в Москве в:

0. В магазине МЦНМО (http://www.mccme.ru/publications/shop.html) за 1100 руб.
1. Дом технической книги
2. Московский дом книги (видимо Арбат)
3. Библиоглобус
4. Дом книги на Соколе
5. Дом книги «Студент»
6. Аргумент (лавки в МГУ)

В Библиоглобусе она стоит примерно 1300 руб.

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

До конца года обещают доставить в питерский Дом книги.

По остальным городам пока непонятно, обновления в комментариях.

В качестве публичного сервиса я могу отправлять книги (пока мне не надоест их заворачивать) по почте в другие города и страны (_не_ в Москву). Это будет стоить 900 руб + стоимость доставки. Чтобы договориться, присылайте письмо с подстрокой #tapl в сабджекте по адресу squadette@gmail.com, и укажите точный проверенный почтовый адрес с индексом. Доставка Почтой России, наложенным платежом (или как-то еще).

Вопросы, пожелания, предложения?

Применение комонад на практике

2011-10-31T15:30:39Z

Всем привет.

Возник, возможно, тривиальный вопрос. Как известно (в частности, из статьи Уодлера "The marriage of effects and monads"), любую разумную систему типов с эффектами (ну или *-passing style) можно транслировать в эквивалентную монадическую систему типов, которая тривиальным образом выражается в виде instance соответсвующей монады, скажем, в Haskell. Примером тому служит region calculus.

При этом, в другой известной статье, "Implicit Parameters: Dynamic Scoping with Static Types", упоминается использование комонад как ограничений на environment, в котором производится вычисление. Другими словами, система типов с комонадами может, теоретически, накладывать ограничения на контекст, в котором типизируется тот или иной терм.

Интересна практическая сторона вопроса. Были ли попытки описать что-нибудь типа co-unit и co-bind в общем случае? Сразу оговорюсь, что частных случаев полно - взять хотя бы популярные нынче системы типов для secure information flow.

Заранее спасибо.

Upd: Кажется, нашёл то, что требовалось, с примерами: Codata and Comonads in Haskell. Richard B. Kieburtz.

Какие библиотеки Haskell показывать студентам?

2011-10-04T07:36:48Z

Уважаемые члены сообщества!

Я в этом семестре читаю курс по функциональному программированию для магистров (Software Engineering), при этом основным языком является Haskell. Ребята достаточно сильные, курс достаточно длинный, поэтому в конце есть время рассказать подробно про какие-нибудь полезные библиотеки.

Ясно, что джентльменский набор начинается с QuickCheck, про него рассказать необходимо. Номер два --- это Parsec, хотя тут я менее уверен; возможно лучше простую подобную библиотеку изготовить ручками, а на Parsec просто сослаться, что, мол, есть.

Какие ещё библиотеки вы можете порекомендовать? Особенно жду ответа от тех, кто применяет Haskell в повседневной работе.

Монадные трансформеры

2011-09-26T05:30:39Z

Допустим, у нас есть собственная монада, составленная как-то так:

data CompileState = CompileState { cdict :: Dict, centry :: Maybe KId, ctmpid :: Int }
                    deriving (Show)

newtype CompileM a = CompileM {
    runT :: StateT CompileState (ErrorT CompileError IO) a
} deriving (Monad, MonadIO, MonadError CompileError, MonadState CompileState)


runCompile :: CompileState
              -> CompileM a
              -> IO (Either CompileError (a, CompileState))

и есть какой-то совершенно посторонний тип:

type M = CheckingFuelMonad (SimpleUniqueMonad) 

runM :: M a -> a
runM m = runSimpleUniqueMonad $ runWithFuel 0 m

До некоторого момента, я запускал вычисления типа M по отдельности:


runCompile $ do
   a <- runM $ ...
   b <- runM $ ...

и в общем, то, что M и CompileM никак не связаны особых неудобств не доставляло. К сожалению SimpleUniqueMonad отвечает за генерацию меток, и так получилось, что теперь нужно сделать сквозную генерацию этих меток, т.е. как-то вытащить SimpleUniqueMonad на внешний уровень:


runCompile $ do
   runM $ do
      a <- f1 :: CompileM ???
      b <- f2 :: CompileM ???
      c <- f3 a :: M x ???

Допустим, можно попытаться добавить M в стек монад CompileM, но что для этого нужно сделать?
Написать собственный трансформер для типа M?

Можно ли это сделать, не вдаваясь в реализацию CheckingFuelMonad / SimpleUniqueMonad ?
Возможно ли добиться желаемого (запустить все вычисления в SimpleUniqueMonad ) как-то проще?

Линейные типы:

2011-09-25T07:08:40Z

Один из сообщников у себя в блоге задает вопрос "уже кто-нибудь усвоил линейную логику в программировании?". Разумеется давно (лет 20 назад) освоили: позволю пару ссылок на Wiki - "Linear types" и "Clean" (Clean если кто не знает - язык очень близкий к Haskell и отличающийся от него пожалуй в основном как раз подходом к трактовке mutable states - именно для этого там и юзаются линейные типы) и на список публикаций Software Technology group of the MBSD section of the CS department of the University of Nijmegen (искать по ключевым словам "linear type" и "unique type").

Идея проста и довольно продуктивна (хотя пока толком почему-то не востребована):

Любой тип может иметь модификатор линейности (в clean она называется "уникальностью") - скажем Int и *Int. "Уникальность" означает, что на данное значение в данный момент времени существует единственная ссылка (а система типов это гарантирует) - если примитивно - то переменную уникального типа можно передать параметром только один раз функцию, а система типов этот контроль обеспечивает (в первом приближении - проверяя что все ее испльзования взаимоисключающие с точки зрения потока данных).

Применений у них два: первое обслуживает ввод-вывод - в Clean не используются монадыю Вместо этого есть тип World(символизирующий окружающий мир), функция Start (аналог main) имеет тип

Start:: *World -> *World,

и есть функции, "отщепляющие" из мира разные другие сущности - файлы, "мир гуевых событий" etc. Выглядит это примерно так:

module test
import StdEnv, StdFile

Start :: *World -> *World
Start world = 
  let (ok,file,world1) = fopen "test.file" FWriteText world in
  let file1 = Process file in
  let (ok,world2) = fclose file1 world1 in
  world2

Process :: *File -> *File
Process file = 
  let file1 = fwrites "Hello,\n" file  in
  let file2 = fwrites "World\n"  file1 in
  file2

функция fopen "отщепляет" *File от *World,возвращая статус, и "новый" *World, fwrites пишет в *File строчку, возвращая "новый" *File. Ну а fclose "вливает" файл обратно "в большой мир"

При попытке использовать "старый" file еще раз будет диагностика времени компиляции:

Uniqueness error: "xxx" demanded attribute cannot be offered by shared object

Обращу внимание на то, что в операция fclose тут необходима вовсе не только в привычном нам смысле сброса буферов etc - если не влить *File обратно в *World - тот как и следует ожидать останется неизмененным - файл даже не создастся: если отвлечься от абстрактных причин - язык ленивый и если значение file1 не будет затребовано - никаких действий ведущих к его вычислению не будет и проделано.

Разумеется такую жуть пишут редко - имеется куча всякого синтаксисического сахара - например - операция <<<:

class (<<<) infixl a :: !*File !a -> *File
instance <<< Char
instance <<< Int
...

и вместо

let file1 = Process file in
let (ok,world2) = fclose file1 world1 in

Можно просто написать

  let (ok,world2) = fclose (file <<< "Hello," <<< "world\n") world1 in

Ну и другие украшательства есть.

Помимо "ввода-вывода" у линейных типов в Clean есть еще одно важное применение: эффективная работа с изменямыми агрегатными данными:

module test2
import StdEnv, StdArray

Start :: *World -> {Int}
Start world =  update (createArray 10 1) 5 10

Напечатает

{1,1,1,1,1,10,1,1,1,1}

В отличие от Haskell операция update тут не вызовет копирования массива:

class Array a e where
  update :: *(a e) Int e → *(a e)  
  createArray :: !Int e -> *(a e)

Ну и последнее - полиморфизм по свойству линейности тип операции конкатенации списков выглядит так:

(++) infixr 5 :: [u:a] w:[u:a] -> v:[u:a], [w<=v]

Что означает, что ++ полиморфна по уникальности типа эемента списков (при этом этот атрибут должен быть одинаков у всех*). Запись же [w<=v] означает, что если результат конкатенации должен быть уникален, то второй аргумент ++ также олжен быть уникальным списком.

PS: Изложение, разумеется, упрощенное - за деталями - в статьи или в четвертую главу описания Clean.

Upd: поскольку с ленивостью возникли непонятки, еще пример:

Process :: Bool *File -> *File
Process b file = 
  let file1 = fwrites "Hello,\n" file  in
  let file2 = fwrites "World\n"  file1 in
  let file3 = fwrites "Galaxy\n" file1 in
  if b file2 file3

В зависимости от первого аргумента в file будет записано либо "Hello, World" либо "Hello, Galaxy"

*) поскольку значение уникального типа может быть использовано как значение обычного типа - на практике это означает, что если хоть в одном из типов списков элемент не уникален - не уникальны они все

Control.Monad.Writer

2011-09-22T05:01:13Z

Насколько хорошая идея использовать Control.Monad.Writer, если то, что я вывожу во Writer является,скажем так, существенной частью вычисления? например, распределение регистров протаскивается по вычислению явно из блока в блок, а сами инструкции байткода пишутся при помощи tell ? Или лучше такого не делать?

Например:


...

    (r, code) <- runWriterT $ do flip runReaderT (trEnvInit dict live p) $ do
                                 mapM trBlock blocks

    trace ("\n\n\n" ++ (intercalate "\n" $ code) ++ "\n\n\n" ) $
      trace (intercalate "\n" $ concat r ) $ error "woops"


    where
      trEnvInit d l p = TREnv d l p

      trBlock b = foldBlockNodesF trNode b (return [])
      trNode :: forall e x . Insn e x -> TrM [String] -> TrM [String]
      trNode x r = tell [show x] >> liftM2 (++) r (return [show x])
...

печатает совсем не то, что ожидалось ( https://gist.github.com/1c409fcaa99ab32a34e5 ) . Хотелось бы использовать именно Writer для упрощения кода, но, видимо, я что-то не понимаю.

Haskell-in-the-web.

2011-09-12T14:23:05Z

Кто-нибудь пробовал на практике писать веб-приложения (клиентскую часть) на хаскеле?
Компиляторы из хаскела в джаваскрипт, yhc, uhc, ghcjs, все мёртвые и из коробки не собираются; поэтому я предполагаю или оставить идею и писать на джаваскрипте, или на хаскеле определить комбинаторы-макросы для js. Про второй вариант вопрос, как это лучше сделать? Хочется упростить работу с асинхронными запросами и уменьшить количество глупых ошибок вида "забыл отписаться от уведомлений при удалении виджета, память утекает" и "не всё обновил при получении новых данных". Также хочется простого способа описания виджетов (в идеале -- type-safe microtemplates с чётко обозначенными слотами для вставки поддеревьев виджетов, без необходимости разносить шаблон и код контроллера в разные файлы), и чтобы можно было делать составные виджеты.

По идее, это всё не очень специфично для web -- во всех (низкоуровневых) gui-библиотеках приложение представляется деревом элементов, логика запрятана в обмене сообщениями-событиями (а сами хэндлеры довольно просты).
Интересно было бы скомбинировать regions и что-то вроде session types, но неясно как и неочевидно, что это проще, чем вручную писать на джаваскрипте.