Язык может иметь мощные макросы Lisp без круглых скобок?

Нет, в этом нет необходимости. Все, что дает вам какой-то доступ к дереву синтаксического анализа, будет достаточно, чтобы позволить вам манипулировать телом макроса так же, как это делается в Common Lisp. Однако, поскольку манипулирование AST в lisp идентично манипулированию списками (что-то, что граничит с easy в семействе lisp), возможно, это не так естественно, если бы "дерево синтаксического анализа" и "письменная форма" были по существу такой же.

Да. Круглые скобки в Лиспе используются классическим способом, как механизм группировки. Отступы - альтернативный способ выразить группы. Например. следующие структуры эквивалентны:

A ((B C) D)

и

A
    B
    C
  D

Скобки не имеют отношения к макросам. Это просто способ работы Лиспа.

Например, в Prolog есть очень мощный механизм макросов, называемый «расширение терминов». По сути, всякий раз, когда Prolog читает термин T, if пытается использовать специальное правило term_expansion (T, R) . В случае успеха интерпретируется содержимое R вместо T.

Совершенно верно. Это просто на пару порядков сложнее, если вам приходится иметь дело со сложной грамматикой. Как заметил Питер Норвиг :

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

>>> parse ("2 + 2")

['eval_input', ['testlist', ['test', [ 'and_test', ['not_test', ['сравнение', ['expr', ['xor_expr', ['and_expr', ['shift_expr', ['arith_expr', ['термин', ['коэффициент', ['мощность', ['атом', [2, '2']]]]], [14, '+'] , ['термин', ['фактор', ['мощность', ['атом', [2, '2']]]]]]]]]]]] ]]], [4, ''], [0, '']]

Это было скорее разочарованием для меня. Синтаксический анализ эквивалентного выражения на Лиспе: (+ 2 2) . Кажется, что только настоящий эксперт захочет манипулировать деревьями синтаксического анализа Python, тогда как деревья синтаксического анализа Lisp просты в использовании для всех. По-прежнему можно создать что-то похожее на макросы в Python путем объединения строк, но это не интегрировано с остальной частью языка, и поэтому на практике это не делается.

Поскольку я не супергений (и даже не Питер Норвиг), я буду придерживаться (+2 2) .

Да, конечно, возможно. Особенно, если это все еще Lisp под капотом:

http://www.meta-alternative.net/pfront.pdf

http://www.meta-alternative.net/pfdoc.pdf

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

Вот сокращенная версия Райнера ответ:

Чтобы иметь макросы в стиле lisp, вам нужен способ представления исходного кода в структурах данных. В большинстве языков единственная «структура данных исходного кода» - это строка, которая не имеет почти достаточной структуры, чтобы позволить вам делать настоящие макросы. Некоторые языки предлагают реальную структуру данных, но она слишком сложна, как Python, так что писать настоящие макросы глупо сложно и не стоит того.

Списки и круглые скобки Lisp - это золотая середина. Достаточно структуры, чтобы с ним было легко справиться, но не слишком много, чтобы вы утонули в сложности. В качестве бонуса, когда вы вкладываете списки, вы получаете дерево, которое оказывается в точности той структурой, которую естественным образом принимают языки программирования (почти все языки программирования сначала разбираются в «абстрактное синтаксическое дерево», или AST, прежде чем будут фактически интерпретированы / скомпилированы. ).

По сути, программирование на Лиспе - это непосредственное написание AST, а не написания какого-либо другого языка, который затем превращается компьютером в AST. Вы могли бы отказаться от парен, но вам просто нужен другой способ сгруппировать вещи в список / дерево. Вы, вероятно, мало от этого выиграете.

Переписывание кода в Tcl способом, узнаваемым схожим с макросами Lisp, является распространенной техникой. Например, это (тривиальный) код, который упрощает написание процедур, которые всегда импортируют определенный набор глобальных переменных:

proc gproc {name arguments body} {
    set realbody "global foo bar boo;$body"
    uplevel 1 [list proc $name $arguments $realbody]
}

При этом все процедуры, объявленные с помощью gproc xyz , а не proc xyz будет иметь доступ к глобальным объектам foo , bar и boo . Весь ключ в том, что uplevel принимает команду и оценивает ее в контексте вызывающего , а list является (среди прочего) идеальным конструктором для подстановки -безопасные фрагменты кода.

У Boo есть красивый синтаксис макроса в кавычках, который использует [| |] в качестве разделителей и имеет определенные подстановки, которые фактически проверяются синтаксически конвейером компилятора с помощью $ переменных. Хотя его просто и относительно безболезненно использовать, его гораздо сложнее реализовать на стороне компилятора, чем s-выражения. Решение Boo может иметь несколько ограничений, которые не повлияли на мой собственный код. Существует также альтернативный синтаксис, который больше похож на обычный объектно-ориентированный код, но попадает в категорию «не для слабонервных», например, работа с деревьями синтаксического анализа Ruby или Python.

Преобразования разбора в Erlang по силе похожи на макросы Лиспа, хотя их гораздо сложнее писать и использовать (они применяются ко всему исходному файлу, а не вызываются по требованию).

У самого Лиспа был короткий опыт использования непарентезированного синтаксиса в виде М-выражений. Это не прижилось в сообществе, хотя варианты этой идеи нашли свой путь в современных Лиспах, так что вы получаете мощные макросы Лиспа без круглых скобок... в Лиспе!