Здравствуйте, Klapaucius, Вы писали:

K>типа того, это история довольно специфического подмножества фя. в предисловии более подробно написано почему это не история лиспа, но вообще про лисп там довольно много написано. в основном, правда, для объяснения того, почему нельзя было вот так просто взять компилятор лиспа и использовать для имплементации фя из этого специфического подмножества.

Прочитал только самое начало. Надеюсь потом найти время, чтобы дочитать. Это большой труд. Спасибо, что поделился с нами!

В защиту лиспа (который CL). Может быть, у тебя в статье есть.

Простейшие АТД легко пишутся на CL средствами самого языка. Что-то типа такого (слегка измененный мой собственный код):

(defun print-xyz-state (state)
  "Print the xyz state."
  (ecase (car state)
    (:no-xyz
     nil)
    (:declared-xyz-id
     (destructuring-bind (&key id) (cdr state)
       `(:xyz :id ,id)))
    (:declared-xyz
     (destructuring-bind (&key xyz) (cdr state)
       (declare (ignore xyz))
       (assert nil nil "Cannot print the declared xyz state.")))
    (:defined-xyz
     (destructuring-bind (&key id xyz abc) (cdr state)
       (declare (ignore xyz abc))
       `(:xyz :id ,id)))))

То есть, тип данных — это просто тегированный список, где в начале сидит ключевое слово (тег), а поля сидят по plist. При сопоставлении с образцом вытаскиваем тег, натравливаем ecase, а потом вытаскиваем данные через destructuring-bind. Это покрывают многие и многие случаи, хотя немного многословно.

Я так понимаю, что АДТ — это одно из твоих личных требований к твоему личному пониманию ФЯ. И вот, АДТ хоть в каком-то варианте, но есть. Пусть в очень упрощенном, но есть. Покрывает 90% вариантов использования.

Тут нужно понимать, что та же clojure очень и очень многое взяла из CL. Если не считать специфическую работу с состоянием, то clojure гораздо ближе по духу тому же CL, чем к scheme (как минимум внешне, но без CLOS, да и контейнеры иммутабельны). В clojure очень сильно чувствуется наследие CL. Там сохранили очень бережное отношение к CL. А я так понимаю, что ни у кого не будет возражений считать clojure как ФЯ (из-за особенностей работы с состоянием. Говоря проще, чем больше вставляют палок в колеса при работе с мутабельным состоянием, тем больше шансов считать язык ФЯ. И тут у того же ocaml и F# все не так просто, а про Scala я вообще молчу, где ООП с мутабельным состоянием встречается не реже, чем ФП. Если бы не иммутабельные коллекции, то я даже не знаю, как много бы осталось в этих языках от ФЯ).