Что потеряет Clojure, перейдя от ведущих круглых скобок, таких как Дилан, Джулия и Сеф?

Ответ 1

Написание макросов стало бы намного сложнее, потому что структура не была бы более простой, если бы вам понадобился другой способ кодирования, где начинаются выражения и останавливаются с использованием синтаксического символа для обозначения начала и конца выражений вы можете написать код, который генерирует выражения, возможно, вы могли бы решить эту проблему, добавив что-то вроде (, чтобы отметить начало выражения...

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

Даже если вы полностью не согласны, это видео стоит того часа.

Ответ 2

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

Дайте им это, и макросы будут намного сложнее правильно писать (и, вероятно, будет еще сложнее писать макросы, которые выглядят и прекрасно действуют со всем новым синтаксисом, который вы ввели к тому времени). И макросы - это не то, что хорошая функция, которую вы можете игнорировать или сделать намного более раздражающей; весь язык (как и любой другой Lisp) строится прямо поверх них. Большинство "видимых пользователем" элементов, которые в clojure.core, включая let, def, defn и т.д., Являются макросами.

Ответ 3

(Ответьте на ответ andrew cooke, который предоставил ссылку на Уилер и Глорию "Readable Lisp Проект S-выражений" )

Ссылка выше - это проект, предназначенный для обеспечения читаемого синтаксиса для всех языков на основе s-выражений, включая Scheme и Clojure. Вывод состоит в том, что это можно сделать: есть способ иметь читаемый Lisp без круглых скобок.

В принципе, проект Дэвида Уилера заключается в добавлении синтаксического сахара к Lisp -подобным языкам, чтобы обеспечить более современный синтаксис, таким образом, чтобы он не нарушал поддержку w130 для доменных языков. Усовершенствования являются необязательными и совместимыми с обратной связью, поэтому вы можете включать столько или меньше, сколько хотите, и смешивать их с существующим кодом.

Этот проект определяет три новых типа выражений:

• завитый-инфиксное-выражение. (+ 1 2 3) становится {1 + 2 + 3} в каждом месте, где вы хотите использовать инфиксные операторы любой арности. (Существует специальный случай, который необходимо обрабатывать с осторожностью, если выражение inline использует несколько операторов, например {1 + 2 * 3}, хотя {1 + {2 * 3}} работает должным образом).
• Neoteric-выражение. (f x y) становится f (x y) (требуется, чтобы между именем функции и ее параметрами не было места)
• Сладкое-выражение. Открытие и закрытие родителей можно заменить (необязательным) семантическим отступом, подобным python. Sweet-выражения могут свободно смешиваться с традиционными скобками s-выражений.

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

(define (gcd_ a b)
    (let (r (% b a))
        (if (= r 0) a (gcd_ r a))))

(define-macro (my-gcd)
    (apply gcd_ (args) 2))

становится:

define gcd_(a b)
    let r {b % a}
        if {r = 0} a gcd_(r a)

define-macro my-gcd()
    apply gcd_ (args) 2

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

Ответ 4

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

Ответ 5

У вас будет Mathematica. Mathematica принимает вызовы функций как f[x, y, z], но когда вы исследуете его дальше, вы обнаружите, что f[x, y, z] на самом деле является синтаксическим сахаром для списка, в котором Head (элемент 0) равен f, а Rest (элементы с 1 по N) {x, y, z}. Вы можете создавать вызовы функций из списков, которые очень похожи на S-выражения, и вы можете разложить неоцененные функции в списки (Hold предотвращает оценку, много например quote в Lisp).

Могут существовать семантические различия между Mathematica и Lisp/Scheme/Clojure, но синтаксис Mathematica - это демонстрация того, что вы можете перемещать левую скобку одним атомом и по-прежнему интерпретировать ее разумно, строить код с помощью макросов и т.д..

Синтаксис довольно легко конвертировать с препроцессором (намного проще, чем семантика). Вероятно, вы можете получить синтаксис, который вы хотите, с помощью умного подкласса Clojure LispReader. Там даже проект, который пытается решить Clojure отложенные круглые скобки, заменив их всеми квадратными скобками. (Это пугает мой разум, что это считается большим делом.)

Ответ 6

Я использовал код C/С#/Java/Pascal, поэтому я подчеркиваю, что код Lisp немного чуждый. Однако это чувство длится всего несколько недель - через довольно короткий промежуток времени стиль Lisp будет казаться очень естественным, и вы начнете ругать другие языки за их "нерегулярный" синтаксис: -)

Существует очень веская причина для синтаксиса Lisp. Ведущие круглые скобки делают логически проще кода для синтаксического анализа и чтения, путем сбора как функции, так и выражений, которые составляют его аргументы в одной форме.

И когда вы управляете макросами кода/использования, важны эти формы: это строительные блоки всего вашего кода. Поэтому принципиально имеет смысл помещать скобки в место, которое точно ограничивает эти формы, а не произвольно оставляя первый элемент вне формы.

Ответ 7

Философия "код - данные" - это то, что делает возможным надежное метапрограммирование. Сравните с Perl/Ruby, которые имеют сложный синтаксис, их подходы к метапрограммированию являются надежными только в очень ограниченных условиях. Lisp метапрограммирование настолько надежно, что ядро ​​языка зависит от него. Причиной этого является единообразный синтаксис, разделяемый кодом и данными (свойство гомоконичности). S-выражения - это способ реализации этой однородности.

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

Например, следующие три выражения эквивалентны:

• (сначала (отдых (отдых [1 2 3 4 5 6 7 8 9])))
• (- > [1 2 3 4 5 6 7 8 9] (отдых) (отдых) (первый))
• (- > [1 2 3 4 5 6 7 8 9] отдохнуть сначала)

Обратите внимание, что в третьем макросе → можно в этом контексте заключить круглые скобки и тем самым оставить их. Существует много особых сценариев, подобных этому. Вообще Clojure дизайн ошибается на стороне меньших круглых скобок. Смотрите, например, спорное решение покинуть из скобки в конде. Clojure является очень принципиальным и последовательным в этом выборе.

Ответ 8

Интересно, что есть альтернативный синтаксис Racket:

@foo{blah blah blah}

читается как

(foo "blah blah blah")

Ответ 9

Were Clojure to go down this path - what would it have to sacrifice to get there?

Жертва принесла бы чувство/ментально-модальное написание кода, создав Список Список Список.. или более технически "прямо написание AST".

ПРИМЕЧАНИЕ. Существуют и другие вещи, которые будут скарифицированы, как указано в других ответах.