Сравнение макросов Common Lisp и возможностей метапрограммирования Forth

На мой взгляд, макросы Common Lisp похожи на немедленные слова Форта. (На самом деле, они больше всего похожи на макросы для чтения Lisp.)

• Оба они являются процедурными макросами, т. Е. Могут использовать все возможности языка.

• У них обоих есть доступ к исходному коду.

• Оба они могут выводить все, что можно выразить на языке. (Например, объектно-ориентированное расширение в Lisp или базовые конструкции потока управления в Forth.)

Основное различие, возможно, будет заключаться в том, что вводимые «макросами» Forth являются символьными строками, а макросы Lisp работают с деревом синтаксического анализа.

Я разработчик Forth и имею большой опыт работы с Forth, полдюжины реализаций, несколько сотен проблем с проекторами. Я также сделал небольшое объектно-ориентированное расширение (маленькое, то есть с десяток строк или около того). Мой опыт в LISP гораздо больше на уровне курса, но я думаю, будет справедливо сказать, что средства метапрограммирования LISP более систематичны и на практике более мощны.

Строить абстракции поверх абстракций в LISP относительно легко. В Forth, если я хочу определить матрицу в линейном пространстве, определяемом объектами с нетривиальными определениями, я переключаюсь на Python.

Причина тоже очевидна, по крайней мере, для меня. Создатели LISP, в котором математики, в то время как Чак Мур являются ярким примером практического программиста, никогда не тратящего свое время на теоретические проблемы.

Это распространяется на этот вопрос следующим образом. Макрос lisp имеет структуру в контексте Lisp и, по крайней мере, предлагает значение, которое соответствует общим принципам lisp. Непосредственное слово Forth - это просто еще одна программа, которая может означать и делать что угодно, включая приготовление из него обеда для собак.

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

У меня только теоретические знания Лиспа, а не практические.

С другой стороны, у Форта могло быть (но у нормального Форта нет) полное метапрограммирование внутри языка. Но метапрограммирование предполагается и возможно, но без связного синтаксиса. Я думаю, что то же самое происходит в Лиспе.

Я реализовал очень чистое решение, которое включает эту возможность в небольшой парадигме языка Forth. Чтобы иметь возможность метапрограммирования, мы должны иметь возможность ссылаться на то, что пишем. Итак, когда мы пишем программу, которая будет выполняться немедленно, как:

bread eat

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

{ bread eat } 

Вышеупомянутая фраза могла, как следствие, оставить созданный объект в стеке. Но поскольку мы создали новое слово как { и }, мы также имеем право ссылаться на него.

Итак, мы хотели бы сослаться на:

{ bread 

Как мы могли это сказать? Предварительный синтаксис: {{ { bread }}.

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

XXX eat }

и фраза выше должна работать правильно, оставляя в стеке

{ bread eat }

Поскольку я не знаю, является ли то, что я говорю, именно то, что вы ищете, достаточно сказать, что по приведенным выше рассуждениям и их реализации внутри Forth каждое слово получает уровень выполнения, и это определяет, какой уровень метапрограммирования слова .

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

Я реализовал все это внутри своего рода форта, и на первом уровне (ниже бесконечности) все работает плавно. Так, например, я могу изменить синтаксис:

{ bread eat } { tomatos eat } x 3 = if 

в:

{ bread eat | tomatos eat } x 3 = if 

Это делается путем определения | как } {, как показано ниже:

{{ } { }} "|" define

или, если вам больше нравится:

2{ } { 2} "|" define 

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

Так что, на мой взгляд, и Лисп, и Форт имеют возможность метапрограммирования, но оба лишены этой возможности как интегрирующей части языка.

У меня есть более подробная информация об этом на napl.wikispaces.com.