Пожалуйста, объясните некоторые моменты Пола Грэма на Lisp

объяснение Мэтта совершенно нормально - и он делает попытку сравнения с C и Java, чего я не буду делать-но по какой-то причине мне действительно нравится обсуждать эту самую тему Время от времени, так что-вот мой шанс на ответ.

по пунктам (3) и (4):

пункты (3) и (4) в вашем списке кажутся наиболее интересными и актуальными сейчас.

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

;; a library import for completeness,
;; we won't concern ourselves with it
(require '[clojure.contrib.string :as str])

;; this is the interesting bit:
(println (str/replace-re #"\d+" "FOO" "a123b4c56"))

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

Итак, предположим, что у нас есть этот код в файле где-то, и мы спрашиваем В Clojure, чтобы выполнить его. Кроме того, давайте предположим (для простоты), что мы прошли мимо импорта библиотеки. Интересный бит начинается с (println и заканчивается на ) далеко вправо. Это lexed / разбирается как можно было бы ожидать, но уже возникает важный момент: результат-это не какое-то специальное представление AST для компилятора-это просто обычная структура данных Clojure / Lisp, а именно вложенный список, содержащий кучу символов, строк и ... в этом case -- один скомпилированный объект шаблона регулярных выражений, соответствующий #"\d+" литерал (подробнее об этом ниже). Некоторые шепелявит добавить свои маленькие завихрения на этот процесс, но Пол Грэм был в основном ссылаясь на общий Лисп. По пунктам, относящимся к вашему вопросу, Clojure похож на CL.

весь язык во время компиляции:

после этого момента все операции компилятора (это также было бы верно для интерпретатора Lisp; код Clojure всегда компилируется) - это Структуры данных Lisp, которыми программисты Lisp привыкли манипулировать. В этот момент становится очевидной замечательная возможность: почему бы не позволить программистам Lisp писать функции Lisp, которые управляют данными Lisp, представляющими программы Lisp, и выводят преобразованные данные, представляющие преобразованные программы, которые будут использоваться вместо оригиналов? Другими словами-почему бы не разрешить программистам Lisp регистрировать свои функции в качестве плагинов компилятора, называемых макросами в Lisp? И действительно любая приличная шепелявость система обладает такой способностью.

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

весь язык во время чтения:

давайте вернемся к этому #"\d+" регулярное выражение буквальное. Как упоминалось выше, это преобразуется в фактический скомпилированный объект шаблона во время чтения, прежде чем компилятор услышит первое упоминание о новом коде, подготовленном для компиляции. Как это происходит?

Ну, как Clojure в настоящее время реализуется, картина несколько отличается от того, что Пол Грэм имел в виду, хотя все возможно с умный Хак. совместно Лисп, история была бы немного чище концептуально. Основы, однако, похожи: читатель Lisp-это конечный автомат, который, помимо выполнения переходов состояний и в конечном итоге объявления о том, достиг ли он "принимающего состояния", выплевывает структуры данных Lisp, которые представляют символы. Таким образом, символы 123 стать номером 123 etc. Теперь наступает важный момент:этот конечный автомат может быть изменен пользовательским кодом. (Как отмечалось ранее, это полностью верно в случае CL; для Clojure требуется Хак (обескураженный и не используемый на практике). Но я отвлекся, это статья PG, которую я должен был бы развивать, так что...)

Итак, если вы программист Common Lisp и вам нравится идея векторных литералов в стиле Clojure, вы можете просто подключить к считывателю функцию, чтобы соответствующим образом реагировать на некоторую последовательность символов -- [ или #[ возможно -- и рассматривать его как начало векторного литерала, заканчивающегося на совпадение ]. Такая функция называется читатель макрос и так же, как обычный макрос, он может выполнять любой вид кода Lisp, в том числе код, который сам был написан с фанки нотацией, включенной ранее зарегистрированными макросами чтения. Так что весь язык во время чтения для вас.

подводим итоги:

на самом деле, до сих пор было продемонстрировано, что можно запускать регулярные функции Lisp во время чтения или компиляции; один шаг, который нужно предпринять отсюда до понимания того, как чтение и компиляция сами по себе возможны во время чтения, компиляции или выполнения, нужно понять, что чтение и компиляция сами выполняются функциями Lisp. Вы можете просто позвонить read или eval в любое время для чтения в Lisp данных из символьных потоков или компиляции и выполнения кода Lisp, соответственно. Это весь язык прямо здесь, все время.

обратите внимание, как тот факт, что Lisp удовлетворяет точке (3) из вашего списка, имеет важное значение для пути в который ему удается удовлетворить точке (4) - особый вкус макросов, предоставляемых Lisp, в значительной степени зависит от кода, представленного регулярными данными Lisp, что является чем-то включенным (3). Кстати, только" древовидный " аспект кода действительно важен здесь-вы могли бы предположительно иметь Lisp, написанный с использованием XML.