Polytypic polyrythm

Reading on continuations

2008-04-08T11:58:04Z

1. Talk: Delimited Continuations in Computer Science and Linguistics
Презентация О. Киселева и К. Шана, которая популярно объясняет значение терминов continuations, delimited continuations, и показывает, каким образом они относятся к операционным системам и лингвистике. Китайские иероглифы вместо привычных греческих букв смотрятся очень свежо.

2. An Analytical Approach to Programs as Data Objects
Диссертация Olivier Danvy. Фундаментальная работа по теории языков программирования, рассматриваются вопросы семантики программ, трансформации программ, частичных вычислений, все изложение построено вокруг понятия "continuation". ^*

^*Я ее еще не осилил, но выглядит как MUST READ. Как минимум, эпиграфы к каждой главе замечательные.

Coding for food

2008-03-15T16:52:45Z

Если вдруг кто не заметил новое сообщество: coding4fun_ru

Загадка

2008-03-05T10:59:17Z

Пришлось по долгу службы вспоминать язык программирования Ц++. До чего же быстро забываются все эти overload resolution'ы, template argument deduction'ы, one definition rule'ы, 2-phase name lookup'ы и пр. без активного использования.

Рассмотрим код единицы трансляции ниже:

#include <iostream>

template <class T>
void f()
{
    std::cerr << "yo whazzup" << std::endl;
}

void g()
{
    f<int>();
}

Рассмотрели? Кто может, не подглядывая в "C++ Templates: The Complete Guide" или в ~~священную корову~~ Стандарт, вообразить ситуацию, в которой замена void на int в объявлении шаблона функции f влияет на вывод функции g?
Дополнение: в коде данной единицы трансляции ничего менять нельзя (кроме типа возвращаемого значения f, естественно).

з.ы. совсем не исключаю, что это все знают, а я один такой деревянный; но язык, в котором такое возможно, - это кошмар, по-моему.

Update.
Внимание, правильный ответ:

Я старался формулировать осторожно, потому надеюсь, что ни для кого не будет сюрпризом, что в загадке приведен не весь код - а именно, опущен код еще одной единицы трансляции (слово "ситуация" подразумевало такую возможность). Предположим, что код из загадки находится в файле b.cpp, а код ниже - в файле a.cpp

#include <iostream>

template <class T>
void f()
{
    std::cerr << "surprise!" << std::endl;
}

template void f<int>();

void g();

int main (int argc, char* argv[])
{    
    g();
    return 0;
}

Программа, скомпилированная командой g++ a.cpp b.cpp (g++ (GCC) 4.1.2 (Ubuntu 4.1.2-0ubuntu4)) печатает "yo whazzup" или "surprise!" в зависимости от типа возвращаемого значения шаблона функции f, определенного в b.cpp.
Я понимаю это так: в разделе 12.2.1 книги "C++ Templates: The Complete Guide" (думаю, можно найти объяснение, основываясь прямо на тексте стандарта, но мне лень) перечисляются случаи, при которых в C++ могут сосуществовать в одной программе одноименные функции. Ключевая фраза:
"Two functions can coexist in a program if they have distinct signatures. We define the signature of a function as the following information: ... Its return type, if the function is generated from a function template". Таким образом, определение шаблонов template <class T> void f() в обеих единицах трансляции нарушает one definition rule, что приводит к Undefined Behaviour. g++ имел право в этом случае залить соседей или вызвать ОМОН, но он просто вызвал ту функцию, которая ему больше понравилась.
Пусть знающие товарищи меня поправят.

Опять барабанщики

2008-02-27T13:54:31Z

http://www.youtube.com/watch?v=KFtc_rpg-Wg

Юный барабанщик

2008-02-22T15:02:43Z

http://www.youtube.com/watch?v=b8TSsiD_ozY

лингвистическое

2008-01-10T15:17:54Z

"doesn't cut it" переводится как "не катит"

Опрос

2007-11-25T10:14:13Z

Уважаемые друзья!
Если бы вас коллеги-программисты попросили повести пару лекций о функциональном программировании, что бы вы рассказали? Первую главу SICP? "Why FP matters" Хьюза? Что-то еще?

Монады и continuations (shift/reset part 1.5)

2007-11-21T18:31:39Z

In America, you execute a program.
In Soviet Russia, a program executes you!

При реализации DSL часто нужна зависимость выражения от
контекста. Нам часто требуется, чтобы что-то происходило за
кулисами. Например, в комбинаторах парсеров состояние парсера —
текущий фрагмент входной строки — передается неявно, и это удобно.

В монаде State за кулисами протаскивается глобальное состояние.

В монаде List недетерминизм является также неявным, каждая строка
зависит от предыдущих.

Ключевой идеей для введения такой зависимости от контекста является
инверсия потока управления. Для этого у нас в распоряжении имеется 2
варианта.

Пишем в ивертированном стиле сами

При использовании библиотек комбинаторов программа собирается из
множества маленьких функций, соединяемых в одно целое при помощи
библиотечных комбинаторов. В типичном выражении вида f
`magicCombinator` g именно magicCombinator решает, когда и сколько раз
вызывать функции f и g (потому это и является примером инверсии
управления).

Примерами этого подхода являются монадный стиль, continuation-passing style,
ленивые потоки из SICP.

Используем continuations

Если выбранный язык программирования поддерживает delimited
continuations, нам не нужно разбивать сложное выражение на множество
маленьких функций, связанных комбинаторами. Мы можем прервать процесс
вычисления сложного выражения в любой момент, захватив текущий
контекст (стек вызовов, то что осталось вычислить), а затем вызвать
захваченный контекст как функцию:
(some..big..expression .. (capture_context ctx (magicCombinator ctx))
..)

Имея в распоряжении continuations, мы можем реализовать любую монаду.

Пример: монада State

;; magic happens here
(define (reflect ma)
  (shift k (bind ma k)))

;; ordinary State monad operations, copied verbatim from Haskell's

(define (return x)
  (lambda (s) (cons x s)))

(define (bind m f)
  (lambda (s)
    (let* ((as1 (m s))
           (a (car as1))
           (s1 (cdr as1)))
      ((f a) s1))))

(define (put x)
  (reflect (lambda (_) (cons (void) x))))

(define (get)
  (reflect (lambda (s) (cons s s))))

(define (run-state m s0)
  ((reset (return (m))) s0))

;; tests

(define (test0) 45)

(define (test1)
  (let ((x (get)))
    (begin
      (put (+ x 5))
      (put (+ (get) (get)))
      0)))

(run-state test0 10) ;; prints (45 . 10)
(run-state test1 10) ;; prints (0 . 30)

Ссылки

Representing Monads by A. Filinski

То же на РСДН, с обсуждением

Металлисты под микроскопом

2007-10-31T09:35:27Z

Музыкальные теоретики изучают творчество Meshuggah.
"Re-casting Metal: Rhythm and Meter in the Music of Meshuggah" by Jonathan Pieslak:
Abstract
Полный текст (sendspace.com)
Забавно.
via ru_meshuggah

shift/reset для самых маленьких, часть 1

2007-10-28T17:38:01Z

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

Введение

Мы познакомимся с очень мощным и опасным инструментом управления
ходом программы - delimited continuations, а точнее, с операторами
shift/reset. Творческое применение shift/reset открывает куда
большие возможности по запутыванию программ, чем могло бы сниться
несчастному goto. Но с другой стороны, continuations можно применять
и в мирных целях, причем в тех областях, где continuations
действительно нужны, их очень трудно чем-либо заменить. В конце
концов, о delimited continuations в последнее время довольно много
пишут, потому любому, кто интересуется теоретической информатикой,
полезно иметь представление об этом звере.

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

О терминологии: русскоязычной литературы по теме я не встречал,
потому термины "continuations", "delimited (partial, composable,
sub-) continuations" оставляю без перевода.

Prerequisites

Большинство примеров кода будет на Scheme.
Язык Scheme выбран по следующим причинам:

1) родная поддержка интересующих нас операторов call/cc и
shift/reset.

Все примеры будут работать в MzScheme 371, если
предварительно импортировать модуль "control.ss":

(require (lib "control.ss"))

2) динамическая типизация (типизация continuations - это отдельная
тема, которой бы не хотелось сейчас касаться).

Контексты и стеки вызова

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

// example 1

int i=1;            // 1
printf("i=%d\n", i);
exit(1);            // 2

Контекст, в котором вычисляется выражение, называют
continuation. Грубо говоря, continuation - это стек вызовов
в данной точке программы.

В традиционных языках (например, Java), прямого доступа к стеку
вызовов у программиста нет, стек вызовов используется специальными
управляющими операторами. Например, инструкция "return 5;" возвращает
управление в точку, из которой была вызвана функция, заменяя вызов
функции значением 5, адрес возврата определяется вершиной стека
вызовов. Инструкция "throw new SomeException();"
"разматывает" стек вызовов до первого подходящего блока catch,
передавая ему объект исключения.

Если бы программист имел доступ к стеку вызовов, он мог бы
самостоятельно реализовать операторы, подобные return или
throw/catch.

В языке Scheme для этого существует оператор call-with-current-continuation, или call/cc.

call/cc

Оператор call/cc захватывает текущий контекст (стек вызовов) и
передает его функции, которая передается оператору call/cc как
аргумент:

    (call/cc (lambda (cont) expression))

cont - это контекст, в котором вычисляется выражение
(call/cc ...). Синтаксически вызов continuation выглядит как вызов
функции, но в отличие от вызова функции, управление из вызова
continuation не возвращается - точно так же, как не возвращается
управление из инструкций return или throw в Java. Вызов (cont x)
в теле expression немедленно передает управление программе в точку
после вызова call/cc, и все выражение принимает значение x. Если в
теле expression обращения к cont не происходит, вычисление выражения
expression завершается обычным образом, и его значение
становится значением всего выражения, завернутого в call/cc.

Рассмотрим пример. В фрагменте кода на языке C, приведенном ниже,
функция div может завершиться "нормально", или, если y=0,
"аварийно":

// example 2

int div(int x, int y)
{
    if (y==0)
        return 0;
    return x/y;
}

void call_site()
{
...
    int a = div(7, 3);
    int b = div(1, 0);
...
}

Ниже приведен аналогичный код на Scheme. Для аварийного выхода из
функции div используется call/cc:

;; example 2

(define (div x y)
  (call/cc (lambda (return)
             (if (= y 0)
                 (return 0)
                 (/ x y)))))

(define (call-site)
  (let ([a (div 7 3)]
        [b (div 1 0)])
    ...))

В следующем примере call/cc используется для досрочного выхода из
функции for-each, благодаря чему мы можем определить функцию find,
которая находит первый элемент списка, удовлетворяющий условию:

;; example 3

(define (find pred xs)
  (call/cc (lambda (return)
             (begin
               (for-each (lambda (x) (when (pred x) (return x))) xs)
               #f))))

(define test-find
  (find odd? (list 2 4 8 19 10 14 13))) ;; возвращает 19

Возможности call/cc не ограничиваются досрочным выходом из функции, в
сети можно найти множество головоломных примеров применения call/cc в
сочетании с set!, с помощью которых реализуют "зеленые потоки",
интерактивные веб-страницы и т.д. Мы не будем вдаваться здесь в
подробности, заметим лишь, что применение изменяемого состояния в
связке с call/cc является признаком эмуляции delimited continuations.

Проблема оператора call/cc - он захватывает весь стек вызовов, в то
время как в большинстве интересных случаев нам нужен лишь его фрагмент.

Знакомимся с shift/reset

Если мы хотим захватывать фрагменты стека вызовов, нам нужен способ
обозначать нужную его часть. Для обозначения границы интересующего
нас контекста служит оператор reset. Если в области действия
оператора reset не происходит обращения к оператору shift, reset не
имеет никакого эффекта: выражение (reset 1) равносильно просто 1,
(reset (+ 1 2 3)) равносильно (+ 1 2 3). (Аналогично, при применении
call/cc, если вызова continuation не происходит, call/cc не имеет
эффекта, (call/cc (lambda (k) 1)) принимает значение 1).

Примечание: в тексте ниже мы будем называть reset-выражением
выражение вида (reset ...), а shift-выражением - выражение вида
(shift k ...)

Все становится значительно интереснее при наличии оператора shift.
Выражение (shift k body):
1) Захватывает фрагмент стека вызовов вплоть до ближайшего
окружающего reset и присваивает его идентификатору k.

2) Прерывает выполнение текущего контекста до ближайшего reset,
значением всего reset-выражения становится body.

3) В body можно обращаться к захваченному контексту k как к функции
произвольное число раз.

Здесь, конечно, необходимы примеры:

;; example 4
(reset (+ 10 (shift k 17))) ;; 17

В последнем примере контекстом вычисления выражения (shift k 17)
является (+ 10 [*]), символом [*] мы обозначим "дыру". Другими
словами, k принимает значение (lambda (x) (+ 10 x)). Но т.к. в теле
оператора shift мы ни разу не вызываем функцию k, контекст
игнорируется, и значением всего выражения становится 17.

;; example 5
(reset (+ 10 (shift k (k 17)))) ;; 27

example 5 отличается от example 4 тем, что после захвата контекста
мы сразу его вызываем. т.к. k = (lambda (x) (+ 10 x)), тело
оператора shift и, следовательно, все выражение принимает значение
27. Обратите внимание, выражение (shift k (k something)) всегда будет
равносильно просто something, потому код в example 5 равносилен

(+ 10 17)

;; example 6

  (let ([xs (reset
             (+ 1 (shift k
                         (list (k 10)
                               (k 20)
                               (k 30)))))]) ;; (11 21 31)
    (for-each (lambda (x) (display (format "~a\n" x))) xs))

В примере 6 мы видим, что захваченный контекст можно использовать как
обычную функцию, которую можно вызывать несколько раз. Контекст
выражения (shift k (list (k 10) (k 20) (k 30))) до reset выглядит так:

(+ 1 [*])

k принимает значение (lambda (x) (+ 1 x)), результатом вычисления
reset-выражения становится список (11 21 31), который затем присваивается
переменной xs и элементы которого печатаются в консоли.

При работе с shift/reset полезно думать о двух видах
контекстов. Во-первых, контекст вычисления reset-выражения, который в
примере 6 выглядит так:

(let ([xs [*]])
    (for-each (lambda (x) (display (format "~a\n" x))) xs))

Из этого контекста видно, что переменная xs используется, как список -
следовательно, reset-выражение при вычислении должно возвращать список.

Тело shift-выражения (list (k 10) (k 20) (k 30)) тоже возвращает
список - именно этот список становится значением всего
reset-выражения.

Во-вторых, контекст, который захватывается оператором shift, в данном
случае это (+ 1 [*]). Чтобы из этого контекста получить осмысленное
выражение, на месте "дырки" нужно подставить число. При каждом из
вызовов (k 10), (k 20), (k 30) аргумент функции k подставляется на
место "дырки", получается эффект многократных возвратов из shift-выражения.

Генерируем последовательности

При помощи shift/reset легко определить операции, подобные оператору
yield в языке Python.

Рассмотрим выражение (reset null). Его значением будет, очевидно,
null - пустой список. Усложним:

    ;; example 7
    (reset
        (begin
            (shift k (cons 1 (k (void)))) ;; (1)
            null))

Оператор shift на строке (1) захватывает текущий контекст k вплоть
до ближайшего reset. Захваченный контекст можно представить в виде выражения с дырой:

    (begin
        [*]
        null)

Как обычно при работе с delimited continuations, нужно определить:
1) что k принимает на вход
2) что k возвращает
3) что станет значением всего reset-выражения

Если мы попробуем подставить произвольные выражения на место дыры в
контексте, мы увидим, что их значения игнорируются - в любом случае
получим null. Значит, continuation k игнорирует свой аргумент,
потому мы будем вызывать его с (void) в качестве аргумента.

Таким образом, k принимает (void) и возвращает список - в данном
случае null. Значением выражения (cons 1 (k (void))) будет список
из одного элемента: (list 1). Т.к. тело оператора shift определяет
значение всего reset-выражения, значением всего выражения в примере 7
будет тоже (list 1).

Еще раз усложним исходный пример:

    ;; example 8
    (reset
        (begin
            (shift k (cons 1 (k (void)))) ;; (1)
            (shift k (cons 2 (k (void)))) ;; (2)
            null))

Если закомментировать строку (1), мы получим выражение, процесс вычисления
которого мы только что разобрали - возвращаемым значением будет
(list 2). Потому example 8 можно переписать:

    (reset
        (begin
            (shift k (cons 1 (k (void)))) ;; (1)
            (list 2)))

Форма полученного выражения нам уже знакома. Повторяя рассуждения,
проделанные для example 7, получим значение example 8: (list 1 2)

Теперь мы можем определить оператор для построения списков:

  (define (yield x) (shift k (cons x (k (void)))))

В контексте выражения, возвращающего список, yield x добавляет x в
голову этого списка. Пример:

 ;; example 9
  (reset (begin
           (yield 1)
           (yield 2)
           (yield 3)
           null))    ;; (list 1 2 3)

Пользуясь yield и for-each, мы можем написать свою версию функции
map:

 ;; example 10

 (define (my-map f xs)
  (reset (begin
           (for-each (lambda (x) (yield (f x))) xs)
           null)))

(define (test)
  (my-map 1+ (list 1 2 3)))  ;; (list 2 3 4)

Если в определении yield заменить cons на stream-cons, мы сможем
генерировать ленивые потоки:

;; example 11

(define (stream-yield x) (shift k (stream-cons x (k (void)))))

(define example3
  (reset (begin
           (stream-yield 1)
           (stream-yield 2)
           (stream-yield 3)
           stream-null)))

Примечание: в MzScheme библиотека потоков, в которой определены
stream-cons и stream-null, импортируется строчкой

(require (lib "40.ss" "srfi"))

Теперь можно определить функцию, преобразующую список в поток:

;; example 12

(define (list->stream xs)
  (reset (begin
           (for-each stream-yield xs)
           stream-null)))

Обход дерева и получение списка/потока узлов остается в качестве
упражнения читателю.

Ссылки

Delimited continuations in operating systems, Oleg Kiselyov,
Chung-chieh Shan

A static simulation of dynamic delimited control, Chung-chieh Shan

A short introduction to call-with-current-continuation

Composable continuations tutorial

To be continued

Не исключено, что продолжение следует. В следующих частях: RAII своими
руками, True Inversion of Control, недетерминированные конечные
автоматы.

Спасибо за внимание.

хорошо быть буддой

2007-10-22T16:49:27Z

В неустанной борьбе с research papers, в стремлении понять наконец-то, о чем же пишет Олег Киселев и компания, достигнута важная веха: я понял, как работают операторы shift/reset, получил смутное представление о delimited (они же partial, composable, sub-) continuations вообще, и о том, что можно делать с их помощью. Например, как можно реализовать "зеленые" потоки, обмен сообщениями в духе Эрланга, Питоно-подобные генераторы и изменяемые переменные. Возможно, если соберусь с духом и кому-то будет интересно, напишу мини-туториал.

Update. Спасибо всем за проявленный интерес, попробую оправдать ожидания

Update 2. Товарищ верь, придет она. Я об обещаниях не забыл, план и примеры кода готовы, текст в процессе.

Geek humor

2007-09-27T08:34:49Z

Из хаскелл-кафе:

> Salary will be within the range 25,134 - 32,796 pounds per year,
> depending on qualifications and experience. The post is available
> immediately, and will be offered on a fixed-term contract for 3 years.

I don't mean to diminish the seriousness of your message, but why is
the salary range so exact? Couldn't you have just rounded the upper
bound to 32,768 for the sake of readability?

Хозяйке на заметку

2007-08-31T13:35:09Z

ghci иногда печатает трудночитаемую кашу:

Prelude> :m +Data.List
Prelude Data.List> tails $ tails [0..5]
[[[0,1,2,3,4,5],[1,2,3,4,5],[2,3,4,5],[3,4,5],[4,5],[5],[]],[[1
,2,3,4,5],[2,3,4,5],[3,4,5],[4,5],[5],[]],[[2,3,4,5],[3,4,5],[4,
5],[5],[]],[[3,4,5],[4,5],[5],[]],[[4,5],[5],[]],[[5],[]],[[]],[]]

По-моему, гораздо лучше читается это:

Prelude Data.List> :m + IPPrint
Prelude Data.List IPPrint> pprint $ tails $ tails [0..5]
    [[[0, 1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [2, 3, 4, 5], [3, 4, 5],
      [4, 5], [5], []],
     [[1, 2, 3, 4, 5], [2, 3, 4, 5], [3, 4, 5], [4, 5], [5], []],
     [[2, 3, 4, 5], [3, 4, 5], [4, 5], [5], []],
     [[3, 4, 5], [4, 5], [5], []], [[4, 5], [5], []], [[5], []], [[]],
     []]

Вот еще более убедительный пример:

Prelude IPPrint Language.Haskell.Parser> parseModule "x=x"
ParseOk (HsModule (SrcLoc {srcFilename = "", srcLine = 1, srcColumn = 1
}) (Module "Main") (Just [HsEVar (UnQual (HsIdent "main"))]) [] [HsPatBind (SrcL
oc {srcFilename = "", srcLine = 1, srcColumn = 1}) (HsPVar (HsIdent "x"
)) (HsUnGuardedRhs (HsVar (UnQual (HsIdent "x")))) []])

Prelude IPPrint Language.Haskell.Parser> pprint $ parseModule "x=x"
    ParseOk
      (HsModule
         (SrcLoc{srcFilename = "", srcLine = 1, srcColumn = 1})
         (Module "Main")
         (Just [HsEVar (UnQual (HsIdent "main"))])
         []
         [HsPatBind
            (SrcLoc{srcFilename = "", srcLine = 1, srcColumn = 1})
            (HsPVar (HsIdent "x"))
            (HsUnGuardedRhs (HsVar (UnQual (HsIdent "x"))))
            []])

Граждане, которые приобретут Visual Studio Team System и Team Foundation Server в предложенных типовых минимальных конфигурациях (или аналогичных по цене) которые скачают файлик [1] и установят обычной процедурой "runhaskell Setup.hs configure && runhaskell Setup.hs build && runhaskell Setup.hs install" смогут pprint'ить что душе угодно (есть ограничение - выхлоп функции show должен быть синтаксически корректным Haskell-выражением).

[1]ipprint-0.2.tar.gz
Update: благодаря Spenser'у Janssen'у (которому, собственно, принадлежит идея) ipprint теперь на Hackage:
http://hackage.haskell.org/cgi-bin/hackage-scripts/package/ipprint

ICFP contest 2006

2007-08-24T10:46:28Z

_adept_ недавно писал о новых задачках в стиле ICFP contest 2006, написанных Алексеем Щепиным. А все ли в курсе, что организаторы ICFP contest 2006 опубликовали исходники - компилятор ML в UM, генераторы головоломок и т.д.?

ГЭБ

2007-08-13T12:10:17Z

Одолел за время отпуска "Гориллы, эму, бабуины - эти буйные гости" Д.Хофштадтера. Книга в целом очень понравилась. Хорошо раскрыты идеи, лежащие в основе доказательства теорем Геделя, и сопутствующий материал - формальные системы, формальная арифметика, диагонализация; интересен экскурс в генетику. Лирические отступления на тему музыки Баха, картин Эшера и дзен-буддизма гармонично вплетаются в ткань книги. Диалоги Ахилла, Черепахи и других написаны с юмором, массой сюрпризов и скрытых смысловых слоев; порадовало пасхальное яйцо, спрятанное в библиографии. Раздел о перспективах ИИ показался слабее остальных - по понятным причинам. Русский перевод не без недостатков - хоть переводчица тесно сотрудничала с автором и проделала титанический труд с целью сохранить игру слов и запутанные связи формы и содержания, бросаются в глаза ошибки в терминологии из области CS.

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

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

з.з.ы. Кто-нибудь знает, где достать "I Am A Strange Loop"?

К вопросу об эффективности композиции

2007-07-06T10:01:45Z

Хотелось бы написать о чем-то возвышенном - например, о delimited continuations и инверсии парсеров, а еще раскритиковать трансформеры монад по ходу дела. Но, к сожалению, я пока мало в этом разбираюсь, потому напишу об обычных списках и функциях.

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

type PartialList a = [a]-> [a]

Подход известный, используется в стандартной библиотеке (см. тип ShowS и связанные с ним функции) и не ограничивается списками - Conal Elliot недавно писал об общем случае.

Конкатенация частичных списков - это просто композиция функций:

emptyPartialList = id

addElem :: a -> PartialList a
addElem x = (x:)

toList :: PartialList a -> [a]
toList p = p []

-- test = [1,2,3]
test = toList $ emptyPartialList . addElem 1 . addElem 2 . addElem 3

Возникает вопрос о границах применимости данного подхода. Если формировать во внутреннем цикле длинные частичные списки - скажем, 20000 элементов - они будут представлены композицией 20000 крошечных функций. Насколько такое представление (не-)эффективно? Я измерил и был удивлен - значительно эффективнее, чем можно было ожидать. Приведенная ниже реализация функции inits разрывает библиотечную реализацию в тряпки:

myInits xs = loop xs emptyPartialList
    where loop [] prefix = [toList prefix]
          loop (x:xs) prefix = (toList prefix) : loop xs (prefix . addElem x)

Код теста:

test :: ([Int]->[[Int]]) -> Int -> Int
test initsf n = sum $ map sum $ initsf $ take n $ cycle [1,-1]

measure expr = do
  t0 <- getClockTime
  r  <- return $! expr
  t1 <- getClockTime
  return (r, diffClockTimes t1 t0)

tests initsf = do
  putStrLn "n\t\tresult\t\ttime"
  putStrLn "============================================"
  mapM_ printTiming [2000, 5000, 10000, 15000, 20000, 25000, 30000]
    where printTiming n = do
            (r, td) <- measure (test initsf n)
            printf "%d\t\t%d\t\t%s\n" n r (timeDiffToString td)

main = do
  putStrLn "Data.List.inits:"
  tests inits
  putStrLn "myInits"
  tests myInits

Результаты:

Data.List.inits:
n		result		time
============================================
2000		1000		1 sec
5000		2500		1 sec
10000		5000		6 secs
15000		7500		32 secs
20000		10000		74 secs
25000		12500		129 secs
30000		15000		196 secs

myInits
n		result		time
============================================
2000		1000		
5000		2500		
10000		5000		1 sec
15000		7500		2 secs
20000		10000		4 secs
25000		12500		6 secs
30000		15000		9 secs

Для полноты картины проверил, насколько хорошо Окамл справляется с десятками тысяч замыканий - оказалось, значительно хуже, чем Haskell:

n               result          time
============================================
2000            1000            0.046000 sec(s)
5000            2500            0.500000 sec(s)
10000           5000            3.125000 sec(s)
15000           7500            8.781000 sec(s)
20000           10000           18.641000 sec(s)
25000           12500           32.905000 sec(s)
30000           15000           52.906000 sec(s)

Полный код теста на Окамле:

type 'a partial_list = 'a list -> 'a list

let empty_partial_list = fun x -> x

let append prefix x = fun xs -> prefix (x::xs)

let to_list p = p []

let iter_inits f xs = 
  let rec loop lst prefix = match lst with
    | [] -> f (to_list prefix)
    | x::xs -> begin f (to_list prefix); loop xs (append prefix x) end
  in
    loop xs empty_partial_list

let rec cycle = 1::-1::cycle

let sum = List.fold_left (+) 0

let rec take n lst = match (n, lst) with
  | (0, _)     -> []
  | (_, [])    -> []
  | (n, x::xs) -> x :: take (n-1) xs

let test n = 
  let ret = ref 0 in
  let process lst = ret := !ret + sum lst
  in (iter_inits process (take n cycle); !ret)

let measure f = 
  let t0 = Sys.time () in
  let r  = f () in
  let t1 = Sys.time () in
    (r, t1 -. t0)

let main () =
  let print_timing n = 
    let (r, td) = measure (fun () -> test n) in
      begin
        Printf.printf "%d\t\t%d\t\t%f sec(s)\n" n r td;
        flush stdout
      end
  in 
    begin
      print_endline "n\t\tresult\t\ttime";
      print_endline "============================================";
      List.iter print_timing [2000; 5000; 10000; 15000; 20000; 25000; 30000]
    end

let _ = main ()

На сегодня все. Надо поработать и почитать диссертацию Анджея Филински "Declarative Continuations and Categorical Duality" - глядишь, будет чего написать и по более интересным вопросам.

Занимательная энтомология

2007-06-01T11:43:57Z

Нашел баг в Visual C# 2005. По крайней мере, народ, знающий C# лучше меня, склоняется к тому, что это таки баг. Если лень ходить по ссылке - поведение программы может зависеть от порядка объявлений перегруженных методов в интерфейсе. Что характерно, баг, похоже, в спецификации языка - никто не смог найти конкретный абзац, объясняющий, как должна интерпретироваться данная программа. Мне кажется, что проблема в отсутствии хоть какого-нибудь подобия формального семантики. Эти жуткие документы - стандарт C++ и спецификация C# - напоминают творение адвокатов, а не инженеров, и сочетают в себе худшее из двух миров: пугающие объемы текста, нечитабельный, непонятный язык и масса возможных неоднозначностей и разночтений.

Когда мы придем к власти, миром будут править Карри и его друг Говард.

A Banda Brasil

2007-05-17T15:12:14Z

Замечательная киевская группа Brasil (brasil_brasil), которая лучше всех на наших просторах исполняет Samba & Bossa Nova, выложила свою демку.

Djinn mode for Emacs

2007-05-17T11:02:41Z

Как известно, Djinn - theorem prover для Haskell, который может выводить определения функций из типов, используя изоморфизм Карри-Говарда.

Теоретически, он должен помогать при написании злых комбинаторов ну очень высокого порядка, тип которых записать легко, а определение - труднее. На практике мне еще не приходилось прибегать к помощи Джинна, но почему-то захотелось иметь поддержку Джинна в Емаксе. Поиск в гугле показал, что в своем желании я не одинок:
And now I greatly desire an Emacs haskell-mode with Djinn built in, so I can type "M-x write-program-at-point RET".

Тем не менее, готового djinn-mode.el не нашлось. Значит, надо делать самому. Emacs-lisp я совсем не знаю, но это не препятствие - есть inf-haskell.el, из которого можно почти все содрать (да здравствует open-source!).
Итого, в настоящий момент имеются функции
M-x inferior-djinn-show - выпускает джинна из бутылки в емаксовский буфер, и
M-x inferior-djinn-define - спрашивает имя и тип, вставляет полученное от джинна определение в текущий буфер.
Хорошо бы добавить функцию, которая будет сканировать определения типов в текущем буфере и отправлять их джинну.
Если это показалось кому-то интересным - вот код:

;;; djinn-mode.el --- Interaction with Djinn in Emacs buffer

;; Copyright (C) 2007  Free Software Foundation, Inc.

;; Author: Gleb Alexeyev gleb.alexeev@gmail.com
;; Almost all code is copy-pasted shamelessly from 
;; inf-haskell.el written 
;; by Stefan Monnier <monnier@iro.umontreal.ca>
;; Keywords: Haskell, Djinn
;; Version: 0.01

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 
;; This file is NOT part of GNU Emacs.
;;
;; This file is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.
;;
;; This file is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.
;;
;; To find out more about the GNU General Public License you can visit
;; Free Software Foundation's website http://www.fsf.org/.  Or, write
;; to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
;; Floor, Boston, MA 02110-1301, USA.


(require 'comint)

;;(define-derived-mode inferior-djinn-mode comint-mode "Inferior Djinn"
;;  "Major mode for interacting with an inferior Djinn process"
;;  (set (make-local-variable 'comint-prompt-regexp) "Djinn> ")
;;  (set (make-local-variable 'comint-input-autoexpand) t))

(defconst inferior-djinn-program-name "djinn")

;;;###autoload
(defun inferior-djinn-show (&optional arg)
  "Show the inferior-djinn buffer.  Start the process if needed."
  (interactive "P")
  (let ((proc (inferior-djinn-process arg)))
    (pop-to-buffer (process-buffer proc))))

(defun inferior-djinn-string-to-strings (string &optional separator)
  "Split the STRING into a list of strings.
The SEPARATOR regexp defaults to \"\\s-+\"."
  (let ((sep (or separator "\\s-+"))
	(i (string-match "[\"]" string)))
    (if (null i) (split-string string sep)	; no quoting:  easy
      (append (unless (eq i 0) (split-string (substring string 0 i) sep))
	      (let ((rfs (read-from-string string i)))
		(cons (car rfs)
		      (inferior-djinn-string-to-strings
		       (substring string (cdr rfs)) sep)))))))

(defun inferior-djinn-command (arg)
  (inferior-djinn-string-to-strings
   (if (null arg) inferior-djinn-program-name
     (read-string "Command to run Djinn: " inferior-djinn-program-name))))

(defvar inferior-djinn-buffer nil
  "The buffer in which the inferior Djinn process is running.")

(defun inferior-djinn-start-process (command)
  "Start an inferior djinn process.
With universal prefix \\[universal-argument], prompts for a command,
otherwise uses `inferior-djinn-program-name'.
It runs the hook `inferior-djinn-hook' after starting the process and
setting up the inferior-djinn buffer."
  (interactive (list (inferior-djinn-command current-prefix-arg)))
  (setq inferior-djinn-buffer
	(apply 'make-comint "djinn" (car command) nil (cdr command)))
  (with-current-buffer inferior-djinn-buffer
    ;;(inferior-djinn-mode)
    (run-hooks 'inferior-djinn-hook)))

(defun inferior-djinn-process (&optional arg)
  (or (if (buffer-live-p inferior-djinn-buffer)
	  (get-buffer-process inferior-djinn-buffer))
      (progn
	(let ((current-prefix-arg arg))
	  (call-interactively 'inferior-djinn-start-process))
	;; Try again.
	(inferior-djinn-process arg))))

(defun inferior-djinn-wait-for-prompt (proc)
  "Wait until PROC sends us a prompt.
The process PROC should be associated to a comint buffer."
  (with-current-buffer (process-buffer proc)
    (while (progn
             (goto-char comint-last-input-end)
             (and (not (re-search-forward "Djinn>" nil t))
                  (accept-process-output proc))))))

(defun inferior-djinn-send-command (proc str)
  (setq str (concat str "\n"))
  (with-current-buffer (process-buffer proc)
    (inferior-djinn-wait-for-prompt proc)
    (goto-char (process-mark proc))
    (insert-before-markers str)
    (move-marker comint-last-input-end (point))
    (comint-send-string proc str)))

(defun inferior-djinn-execute-cmd (cmd)
  "Execute arbitrary Djinn command"
  (interactive "s Enter a command: ")
  (let ((proc (inferior-djinn-process)))
    (with-current-buffer (process-buffer proc)
      (let ((parsing-end                ; Remember previous spot.
             (marker-position (process-mark proc))))
        (inferior-djinn-send-command proc cmd)
        ;; Find new point.
        (goto-char (point-max))
        (inferior-djinn-wait-for-prompt proc)
        ;; Move to previous end-of-line
        (end-of-line 0)
        (let ((result
               (buffer-substring-no-properties
                (save-excursion (goto-char parsing-end)
                                (line-beginning-position 2))
                (point))))
          ;; Move back to end of process buffer
          (goto-char (point-max))
          (if (interactive-p) (message "%s" result))
          result)))))

(defun inferior-djinn-define (name type)
  "Infer definition and insert into current buffer"
  (interactive "s Name: \ns Type: ")
  (let ((def (inferior-djinn-execute-cmd (concat name " ? " type))))
    (if (string-match ".* cannot be realized" def)
        (progn
          (insert (concat name " :: " type "\n" name " = undefined\n"))
          (message "Djinn failed to deduce definition"))
      (insert (concat def "\n")))))

Генуин

2007-04-23T06:04:34Z

"Выпей генуину!" - сказал виндоус юзеру, пожелавшему скачать апдейты.

И опять об умственном чтиве

2007-04-20T12:58:49Z

В тот момент, пока я это пишу, на заглавной странице LtU висит ссылка на статью Д. Тернера Church’s Thesis and Functional Programming.
Пролистал, понял от силы процентов двадцать. Но у статьи есть несомненное достоинство - при своем скромном объеме в 21 страницу она может служить отличной картой PLT. Если ее распечатать в виде плаката и повесить на стену, можно будет при прочтении практически любой работы в области языков программирования воткнуть флажок "You are here".

Lytdybr

2007-04-19T14:38:55Z

Потихоньку сбывается мечта идиота - применяю Haskell в реальной работе. Не так, конечно, как Lennart Augustsson в Credit Suisse, скромнее: прототипирую на Хаскеле, переписываю на чем попало (C#, например). Данных для серьезной статистики пока маловато, но на последнем написанном куске соотношение объемов кода C#/Haskell при одинаковой функциональности приблизительно равно 10.
До чего же скучно переписывать, доложу я вам...

palm_mute @ 2007-04-12T23:07:00

2007-04-12T19:24:54Z

Автобус, которого дожидался Малаки Констант, в то утро опоздал на два часа - по причине снегопада. А когда автобус подошел, было уже поздно - Малаки Констант был мертв.

Mutable variables eliminated from .NET

2007-04-01T18:36:43Z

Приз за самую лучшую первоапрельскую шутку в моей френд-ленте присуждается lambda-the-ultimate.org:

Mutable variables eliminated from .NET

Redmond, WA: At an unusual press conference held this Sunday morning, Bill Taylor, Microsoft's General Manager of Platform Strategy, announced that after much research into the causes of security holes and instabilities, Microsoft will eliminate mutable variables from the .NET platform and its languages, including C# and VB.NET. "One of our top researchers found that mutable variables were the major root cause preventing us from achieving the great user experience we always strive to deliver," said Taylor. "Once we realized that, eliminating them from .NET was a no-brainer."

Given that this announcement was made on a Sunday, reactions have been limited so far, but one prominent VB.NET developer commented that "Compared to the switch from VB6 to VB.NET, this ought to be a breeze." A C# developer was heard to say, "After anonymous delegates, monads shouldn't be a problem."

To ensure wide penetration of this significant update, Microsoft will be issuing updated Windows CDs to all licensed customers, free of charge. The new CDs can be identified by the distinctive holographic "Haskell Inside" logo, featuring a holographic version of this portrait of Simon Peyton-Jones, grinning from ear to ear.

LtU readers are encouraged to share any inside info they may have about this move!

from http://lambda-the-ultimate.org/node/2164

PLAI

2007-03-20T10:29:19Z

Нашел в сети книгу о языках программирования (бесплатную, кстати):
Programming Languages: Application and Interpretation by Shriram Krishnamurthi

На первой же странице автор выдвигает идею о второстепенности синтаксиса и приводит такой пример:

For instance, consider the following three code fragments:

1. a [25] + 5
2. (+ (vector-ref a 25) 5)
3. a [25] + 5

Which of these two is most like each other? The first and second, obviously! Why? Because the first is in Java and the second is in Scheme, both of which signal an error if the vector associated with a has fewer than 25 entries; the third, in C, blithely ignores the vector’s size, leading to unspecified behavior, even though its syntax is exactly the same as that of the Java code.

Книга мне уже определенно нравится :).

Polytypic polyrythm

Reading on continuations

Coding for food

Загадка

Опять барабанщики

Юный барабанщик

лингвистическое

Опрос

Монады и continuations (shift/reset part 1.5)

In America, you execute a program.In Soviet Russia, a program executes you!

Пишем в ивертированном стиле сами

Используем continuations

Ссылки

Металлисты под микроскопом

shift/reset для самых маленьких, часть 1

Введение

Prerequisites

Контексты и стеки вызова

call/cc

Знакомимся с shift/reset

Генерируем последовательности

Ссылки

To be continued

хорошо быть буддой

Geek humor

Хозяйке на заметку

ICFP contest 2006

ГЭБ

К вопросу об эффективности композиции

Занимательная энтомология

A Banda Brasil

Djinn mode for Emacs

Генуин

И опять об умственном чтиве

Lytdybr

palm_mute @ 2007-04-12T23:07:00

Mutable variables eliminated from .NET

Mutable variables eliminated from .NET

PLAI

In America, you execute a program.
In Soviet Russia, a program executes you!