Синтаксис и LISP'ы

)))))))))))))))))))

Имеется в виду, что этот синтаксис прост и фактически без особых изменений определяет AST

Именно так.

Когда синтаксис (+ (* 2 2) (* 3 4)), то AST очевидно, а когда 2*2+3*4, то надо учитывать порядок операций.

Соответственно проще декомпозиция и, при необходимости, контекстная замена операций.

Формат программы определяется reader'ом, который сама программа может переопределить. Я так делал для быстрого перегона данных внешних в s-форму.

Да и штатный легко управляется.

Нет операторов, ключевых слов, которых нельзя переопределить.

Нет предопределённого синтаксиса, так как есть макроопределения, которые позволяют управлять парсером и влиять на выдаваемое AST. В некоторых Лиспах нет и предопределённой лексики, так как есть доступ к readtable, который позволяет управлять лексером и влиять на читаемые sexprs.

s-expr'ы - это тоже синтаксис. Тем более, что во многих лиспах они не чистые.

которые позволяют
который позволяет
позволяет
позволяет
позволяет

За красивыми словечками где то спряталась суть дела.

Macro={
 self: function(){/**/},
 value: function(){},
 cerate: function(){return Object.create(this)},
 re: /\/\*([\s\S]*)\*\//,
 expr: function(){with(this) {return (self+"").match(re)[1]}},
}

with(macro=Macro.create()){
 self=function(){
  /* 
     foo
     foo
     foo
  */
 },
 value=Function(
      expr()
        .replace(/foo/g, "baz();")
    )
}

baz=function(){alert("hello!")}
macro.value()


// ::: hello!
// ::: hello!
// ::: hello!
[/js]
В JS нет синтаксиса? Какая нахрен разница, список или строка? Может пора прекратить демагогию?

Ну так перепиши без with. Он к делу не относится. Да и strict mode твой я советую засунуть в жопу подальше, если ты не девочка.

Буквально это выражается в отсутствии жесткой привязки собствено объектов к их символьному представленю в тексте. Так круглые скобки это лишь общепринятая условность которой конкретный пркладник может и пренебречь и заменить на какие-нибудь диграфы. Пример утрированый :) В переносном смысле подразумевают отказ от нескобочного «сахара» в угоду простоты кодогенерации. Пишем программы которые пишут программы!

синтаксис прост и фактически без особых изменений определяет AST?

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

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

То есть, лисп настолько суров, что может сделать вот так:

curlyBrackets := method(call evalArgs)
squareBrackets := method(call evalArgs)

write(
 {1,2,3}, "\n",  [1,2,3]
)

# ::: list(1, 2, 3)
# ::: list(1, 2, 3)

Это помоему даже в примерах стандарта есть.

Io is a ... programming language inspired by ...

LISP (code is a runtime inspectable/modifiable tree) ...

lisp is a ... programming language inspired by ...

JAVA (code is not a runtime inspectable/modifiable tree) ...

Покажи этот пример.

что делает этот код?

В переносном смысле подразумевают отказ от нескобочного «сахара» в угоду простоты кодогенерации. Пишем программы которые пишут программы!

То есть вот это:

(()''#(caaaadr((',(cdaar'',,',(caaadddddddr'(expr)))))))

С момента определения синтаксиса []{} мы можем использовать его вместо list(). И это остается выражением языка, first-class, как и ф-ция. В Io все есть выражение. Это, по-сути, и означает отсутствие синтаксиса, если по хорошему то рассуждать. А в сраном лиспе ты спецформы никуда не денешь. Да и макросы — это не выражения. Так что это все пиар на пустом месте.

Это, по-сути, и означает отсутствие синтаксиса

Нет, это как раз означает обратное. Отсутствие синтаксиса = синтаксис выражается минимальным набором грамматических правил.

А что, разве у меня обернуто что-то куда-то? Я так понимаю, у тебя это работает только внутри module m2? Если это так, то это детсад.

мало синтаксиса — не означает отсутствие его. Отсутствием синтаксиса можно считать отсутствие спецформ.

Я так понимаю, у тебя это работает только внутри module m2?

Работает где сделано (require 'm) очевидно. Можно специфицировать поведение хоть для каждого модуля по-своему.

Если это так, то это детсад.

В чем детсад? Везде, где а захочу, оно будет работать, как я захочу. А что тебе еще надо?

Отсутствием синтаксиса можно считать отсутствие спецформ.

Спецформы - это семантика, а не синтаксис.

мало синтаксиса — не означает отсутствие его.

«Отсутствия синтаксиса» (формального) быть не может. Если у тебя есть текст, то есть синтаксис. По-этому под «нету синтаксиса» подразумевается «синтаксиса очень мало, самый минимум».

Получается, макросы в лиспе мало чем отличаются от «макросов» в JS

Macro={
 self: function(){/**/},
 value: function(){},
 cerate: function(){return Object.create(this)},
 re: /\/\*([\s\S]*)\*\//,
 expr: function(){with(this) {return (self+"").match(re)[1]}},
}

with(macro=Macro.create()){
 self=function(){
  /* console.log({1,2,3})
  */
 },
 value=Function(
      expr()
        .replace(/\{/, "[")
        .replace(/\}/, "]")
    )
}

macro.value()

// ::: [ 1, 2, 3 ]

Спецформы - это семантика, а не синтаксис.

разупорись

Если у тебя есть текст, то есть синтаксис

Значение любого куска этого текста может быть переопределено, в этом суть.

Везде, где а захочу, оно будет работать, как я захочу. А что тебе еще надо?

Подозреваю, что вот так не будет работать.

write(
 {{1,2,3}, [1,2,3]}, "\n",  [{1,2,3}, [1,2,3]]
)

# ::: list(list(1, 2, 3), list(1, 2, 3))
# ::: list(list(1, 2, 3), list(1, 2, 3))

Ещё один не читал, но осуждает.

Часто можно наткнуться на мнение, что у лиспа(ов) нет синтаксиса. Хотелось бы понять, что конкретно тут имеется в виду.

Какая разница? Всё равно там нифига не понимают, что говорят.

В лиспе ДО ФИГА синтаксиса. Кажый макрос вводит новый кусок синтаксиса. Сколькими макросами пользуешься — столько синтаксиса тебе учить.

А скобочки — это уже так, дело десятое.

В лиспе ДО ФИГА синтаксиса. Кажый макрос вводит новый кусок синтаксиса.

Так это семантика, а не синтаксис, если не ошибаюсь.

А покажи как сделать то же самое, но чтобы элементы в {} и [] разделялись пробелом, а не запятой.

Получается, макросы в лиспе мало чем отличаются от «макросов» в JS

коненчо, отилчаются. В js нет компайлтайма и, следовательно, макросов.

Подозреваю, что вот так не будет работать.

Конечно же будет:

> (module m racket
    (provide (rename-out [app #%app]))
    (define-syntax (app stx)
    (define parens (syntax-property stx 'paren-shape))
    (syntax-case stx ()
      [(_ args ...) (if (or (eq? parens #\[) (eq? parens #\{))
                        #'(list args ...)
                        #'(#%app args ...))])))
> (require 'm)
> (display (~a {{1 2 3} [1 2 3]} #\newline [{1 2 3} [1 2 3]]))
((1 2 3) (1 2 3))
((1 2 3) (1 2 3))
> 

Алсо, если у тебя в 10 разных библиотеках скобочки поразному определены, и я хочу импортировать все 10 этих библиотек, то будет работать? Или один импорт насрет в другой и досвидос?

Так это семантика, а не синтаксис, если не ошибаюсь.

Именно. Но хачкелисты обычно не знают даже таких вот базовых вещей.

И еще переопределить запятую. можно же?

Ну и еще хотелось бы посмотреть на переопределение _круглых_ скобок.

То есть, при каждом новом случае применения ты будешь писать свой макрос? LOL

Так это семантика, а не синтаксис, если не ошибаюсь.

Ошибаешься. Многие макроопределения так и называются, типа define-syntax syntax-rules и тд.

можно

curlyBrackets := method(
 call message arguments at(0) asString split()
)
squareBrackets := getSlot("curlyBrackets")

write({1 2 3}, [1 2 3])

# ::: list(1, 2, 3)list(1, 2, 3)

посмотри, посмотри, сынок

setSlot("", method(call evalArgs))

write((1,2,3))

# ::: list(1, 2, 3)

Я не сомневался, что можно. Просто было интересно как.

это значит, что у лиспов нет синтаксиса программ.

То есть, при каждом новом случае применения ты будешь писать свой макрос?

Не понял, о чем ты. Один раз пишем один макрос, там, где хотим его использовать - импортируем (один раз).

Тему уже все забыли. Ну и х с ней, это ж ЛОР.

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

Жалко, что нам лисперы пока ничего внятного, кроме клоунады не показали.

Так ты ничего ещё не просил показать. Проси, чо.

Ошибаешься.

Нет, не ошибается. На синтаксис макросы никак не влияют.

Многие макроопределения так и называются

ну да, define-syntax - определить семантику синтаксической единицы.

Жалко, что нам лисперы пока ничего внятного, кроме клоунады не показали.

Ну все что ты тут продемонстрировал с переопределением скобок я показал в том же виде. А вот теперь покажи мне, как заставить работать вместе несколько библиотек, каждая из которых переопределяет скобки по-своему.

И где ты тут что переопределил? ((1,2,3)) должно быть list(list(1,2,3))

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

И где ты тут что переопределил?

Я переопределил ровно то, что просили

переопределение _круглых_ скобок.

должно быть list(list(1,2,3))

что должно быть? Это список включающий один список, все равно что лисповский (list (list 1 2 3)) так оно и есть по-дефолту

тогда почему ты переписал первоначальный вариант

В каком месте я его переписал? Один и тот же макрос, слово в слово.

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

Так написал же.

Я переопределил ровно то, что просили

Нет. у тебя в write() скобочки не переопределены.