Ты всех сделал, ура!

Вот так то, Мань. Обоссал тебя.

Ура! Ты всех победил!!!

Итак, лисп — самый мощный из существовавших и существующих языков программирования! Он универсален, функционален и практичен! Сообщество лисперов — самое дружелюбное и адекватное! Лисперы не принимают наркотики и алкоголь и не ругаются матом! А вы все неосиляторы, у вас у всех баттхерт, баттхерт и баттхерт! На лиспе на самом деле написано полно софта, только вам, быдлу, его никто не покажет! Даже самый захудалый лиспер в 10 раз продуктивнее любого жабабыдлокодера, и зарабатывает в 10 раз больше!!!!1111

Тут лиспер очнулся. На столе стояла недоеденная тарелка борща, который давно остыл. Лиспер встал с дивана, отряхнул перхоть с немытой головы и сигаретный пепел с давно не стираных джинсов. Сев за стол, лиспер пододвинул к себе клавиатуру, вчерашние пятна спермы на которой уже успели засохнуть. Экран ожил, показав окошко Emacs со SLIME. Лиспер прикинул, чем он будет сегодня заниматься: писать свой диалект лиспа, свою LISP OS или же делать LISP-процессор на FPGA.

Ночка предстояла длинная.

Раньше я с большим удовольствием читал срачи «LISP vs. нормальные языки».

Потом, к моему нескрываемому интересу, появились срачи «LISP vs. Haskell».

Затем, к моему бурному восторгу, возник срач «LISP vs. Scheme».

Надо ли говорить, что сейчас, в контексте срача «LISP-1 vs. LISP-2», я испытываю что-то вроде интеллектуально-эстетического оргазма?

Надо ли говорить, что сейчас, в контексте срача «LISP-1 vs. LISP-2»

Да они же стары как мир. Были еще до «общелисп вс схеме» или «лисп вс хачкиль».

Значит, я слоупок. Тогда ждем срачей «LispWorks vs. Allegro CL» или «CLOS vs. non-CLOS»

«CLOS vs. non-CLOS»

Ты не поверишь.

Что?

ты чо несешь, в ракете все модульное

Это содержательный смысл lisp-2. А преимущество в чем?

Ну так что? В каком тут месте преимущество lisp-2 укажешь?

О яебу ты дебил. Десяток строк адекватного кода не CL не осилил. Ты обратил внимание на сущность «list», которая представлена как и в sql запросе, так и в качестве идентификатора переменной lisp? Что будешь делать в lisp-1, а? Напишешь правила трансляции идентификаторов совпадающих со стандартными функциями? Каким хуем ты в cхеме или кложуре переопределишь стандартные функции в лексическом скоупе? В этом и состоит суть CL — крайне грамотная продуманность с прицелом на практику. С практикой приходит понимание игрушечности не только многих блабов, но и диалектов Lisp. Тебе и макросы привели и пояснили за чёткое разделение пространств имён, а ты продолжаешь строить из себя целку, касательно не понимания преимуществ lisp-2(n).

(defmacro delay (form)
  `(lambda () ,form))

(defmacro force (delayed)
  `(if (functionp ,delayed)
       (funcall ,delayed)
       ,delayed))

(defun take/lazy (n list)
  (when (and (> n 0) (consp list))
    (cons (first list) (delay (take/lazy (1- n) (force (rest list)))))))

(defun map/strict (fn list)
  (do ((it list (force (rest it))))
       ((not (consp it)))
    (funcall fn (first it))))

;;;;

(defun fib (a b)
  (cons a (delay (fib b (+ b a)))))

(map/strict #'print (take/lazy 1000000 (fib 1 1)))

Не знаю какую магию делает lazy-seq по сравнению с delay/force, но на таком тупом примере SBCL работает быстрее :)

Итак, лисп — самый мощный из существовавших и существующих языков программирования! Он универсален, функционален и практичен!

Как не парадоксально и пафосно не звучит, но это правда, чёрт возьми!

Сообщество лисперов — самое дружелюбное и адекватное!

Касательно дружелюбности — спорный вопрос. А вот касательно адекватности, то именно так и есть. Но товарищей крайне мало :( Это беда, трагедия.

Лисперы не принимают наркотики и алкоголь и не ругаются матом!

Ортогональные вещи. Просто lisp-еры всегда готовы обоссать дебилов.

На лиспе на самом деле написано полно софта, только вам, быдлу, его никто не покажет!

Современного софта на Lisp-е написано крайне мало. Но, в действительности, это не показатель технологичности языка.

Тут лиспер очнулся. На столе стояла недоеденная тарелка борща, который давно остыл. Лиспер встал с дивана, отряхнул перхоть с немытой головы и сигаретный пепел с давно не стираных джинсов. Сев за стол, лиспер пододвинул к себе клавиатуру, вчерашние пятна спермы на которой уже успели засохнуть. Экран ожил, показав окошко Emacs со SLIME. Лиспер прикинул, чем он будет сегодня заниматься: писать свой диалект лиспа, свою LISP OS или же делать LISP-процессор на FPGA.

Ночка предстояла длинная.

Блин, как быстро тебя порвало. Я думал ты хоть денёк продержишься. Но нет, порвался; как дешёвый гандон. Китайцами сделанный.

Современного софта на Lisp-е написано крайне мало. Но, в действительности, это не показатель технологичности языка.

Естественно.

Это показатель его убогости.

Я имел в виду, что неотключаемые батарейки — это не батарейки.

Хм... я всегда думал, что у языка «много батареек» - это когда «из коробки» (без сторонних библиотек) доступно много всего разного.

А уж надо ли для этого стандартные либы/модули подключать или оно «сразу» доступно, на мой взгляд, не так важно.

Ты обратил внимание на сущность «list», которая представлена как и в sql запросе, так и в качестве идентификатора переменной lisp? Что будешь делать в lisp-1, а?

Я сделаю так:

(begin-for-syntax
  (define-syntax-class binding
    (pattern (id:id str:str))
    (pattern id:id
             #:with str #`#,(let ([s (symbol->string (syntax-e #'id))])
                              (string-replace (if (sequence-ormap char-lower-case? s)
                                                  s
                                                  (string-downcase s))
                                              "-" "_"))))
  
  (define (get-sql bstrs table)
    (~a "SELECT " (apply ~a bstrs #:separator ", ") " FROM " table)))

(define-simple-macro (do-select ((b:binding ...) table:binding) body:expr ...+)
  #:with sql #`#,(get-sql (syntax->datum #'(b.str ...)) (syntax-e #'table.str))
  (with-rows ([row sql])
     (match row 
       [(list b.id ...) body ...])))

Каким хуем ты в cхеме или кложуре переопределишь стандартные функции в лексическом скоупе?

Ну просто беру и передопределяю:

(let ([huy +]
      [+ 1])
  (huy + +))

->
2

Тебе и макросы привели и пояснили за чёткое разделение пространств имён

Кто, что пояснил? Пока что в качестве достоинства лисп-2 ты привел его недостаток - необходимость делать восход солнца вручную там, где в нормальных языках все делает компилятор, автоматически.

Не знаю какую магию делает lazy-seq по сравнению с delay/force

seq работает с последовательностями, а твой пример - только со списками.

Ок.

а твой пример - только со списками

А хрен знает, может я не из #:cl импортирую.

Но вообще в этом плане так и получается

основная разница между CL и clojure: CL «все можно сделать», clojure - «все сделано искаробки бери и пользуйся» + определенная направленность на конкретные ниши

«много батареек» - это когда «из коробки»

Нужно объяснять происхождение фразы «batteries included»?

исключительные преимущества CL ... Всего этого нет в Clojure и практически нет нигде.

В Racket есть практически всё из этого.

макросистема (с макросами ридера и компилер-макросами)

Есть. + пачка удобных утилит для написания типовых макрсов.

CLOS

Стандартно нет. Есть https://github.com/Kalimehtar/gls Позволяет диспатчить методы не только по классам, но и по произвольным типам (то есть произвольным предикатам). Например:

(define (fact x)
  (defgeneric fact0
    (method ((n (and? <integer> (<=/c 1))) (acc <integer>))
            acc)
    (method ((n <integer>) (acc <integer>))
            (fact0 (- n 1) (* acc n))))
  (fact0 x 1))

Также, как видно из примера, необязательно делать generic глобальным.

сигнальный протокол,

В явном виде нет. Но любая яконструкция на handler-bind/handler-case/restart достаточно легко реализуется с той же семантикой.

развитая система типов

Есть. + есть Typed Racket, где они полностью проверяются статически

практичная и продуманная стандартная библиотека

Пакет cl? Практичная: iterate лучше, чем loop. В остальном согласен.

Продуманная? fboundp, но special-operator-p. (elt seq n) и (nth n list). И всё это в одном пакете!

Ну и пакеты по сравнению с модулями Racket очень сильно проигрывают. Для аналогичных результатов приходится перебивать readtable (например, https://github.com/Kalimehtar/advanced-readtable) и дополнительно прописывать пакет в asdf.

наличие отличных компиляторов CL

Есть.

интерактивная разработка в лице slime

В Racket есть geiser (полный аналог slime) и DrRacket с возможностью в процессе написания видеть синтаксическую проверку написанного.

с возможностью в процессе написания видеть синтаксическую проверку написанного.

Справедливости ради - это не просто синтаксическая проверка, а постоянный экспанд в отдельном потоке. То есть там проверяется все, что проверяется при раскрытии макросов - например те же типы.

Какие костыли потребовались бы для реализации подобного на CL я даже боюсь себе представить.

постоянный экспанд в отдельном потоке

Какие костыли потребовались бы для реализации подобного на CL

Запуск macroexpand при изменении текста?

Кстати, может знаешь, почему к DrRacket принципиально не хотят прикрутить нормальный autocompletion? Сейчас там только поиск по всей документации, хотя даже slime видит текущее окружение и даёт символы из него.

Запуск macroexpand при изменении текста?

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

Кстати, может знаешь, почему к DrRacket принципиально не хотят прикрутить нормальный autocompletion?

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

Clojure. Более динамично развивается, востребован.

Но вообще в этом плане так и получается

Ну да. Т.е. если тебе всего этого хочется, то придется самому: переписать компилятор, набор стандартных ридер-макросов и структур данных, а значит и стандартную библиотеку, убедить группу людей, а затем и большУю группую людей в том, что это Ъ, вести с ними общение, дискутировать, поддерживать динамику разработки итд итп. Зачем? Если clojure уже есть.

Даже если clojure тебе чем-то серьезно не подходит - все равно придется как всегда «написать свой лисп». И, скорее всего, он снова будет сделан не на CL.

Чистое ФП в виде кложуры [...] бОльшую декларативность (а следовательно и выразительность) кода.

Декларативность, (следовательно) выразительность... «чистое» ФП... Что ты несёшь? Похоже на какой-то маркетинговый bullshit объёбаных функциональщиков. Далеко не всегда выразительность определяется «бОльшей» декларативностью. Эти вещи вообще ортогональны. И ФП никогда не являлся инструментом построения произвольных абстракций. А вот макросистема Lisp — являлась и является (наряду с другими известными подходами).

Ну, я же написал - *современные*. *ML - трупики, erlang используется в такой нише, ...

Хаскель - игрушка для борщехлебов.

Фактически, ты сейчас объяснил всем, что вся нынешняя функциональная братия — немощна, умерла или в нишах. И единственный действительно ленивый ФЯП Haskell ты определил как «игрушка для борщехлебов». Круто, что тут скажешь... Будь любезен, расскажи о «современных» функциональных языках, помимо, «функциональной» кложуры :) Очень интересно послушать.

Да почему же? Аналог slime есть, вполне приличный.

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

Стандартная библиотека тоже ok.

Хз. С виду всё вроде не плохо, но надо разбираться детально. В этом вопросе сейчас я не компетентен.

Зайди на сайт кложуры и посмотри, что ли.

Синтаксис для основных структур данных - кортежи, словари, векторы итд.

Ну пиздец. Разбег на рубль — прыжок на копейку. Ты в курсе, что синтаксис: {} — словарь, [] — вектор, — имеет место быть чуть ли ни в каждом ЯП? Не огорчай меня такими заявлениями... Гвидобейсик тут ни при чём совершенно.

Немного?? Ты сравни y-комбинатор на общелиспе и на схеме.

Взял отсюда: http://rosettacode.org/wiki/Y_combinator:

(defun Y (f)
  ((lambda (x) (funcall x x))
   (lambda (y)
     (funcall f (lambda (&rest args)
		  (apply (funcall y y) args))))))

(define Y
  (lambda (f)
    ((lambda (x) (x x))
     (lambda (g)
       (f (lambda args (apply (g g) args)))))))

Также хочу заметить, что в CL Y combinator на хуй не нужен — есть alambda.

Я сделаю так: ...

и в чем проблема, собственно?

Приведи пожалуйста пример использования макроса (сходного с моим примером [с символом list]) и его macroexpand.

Common Lisp

Ну просто беру и передопределяю:

Окей (хотя полезность сомнительна; в sbcl, например, не быть такому поведению, ввиду package locks). Но вернёмся к примеру: что делать с идентификатором list? мы же не сможем в теле обратиться к этой часто используемой функции. Тогда как в «Lisp 2» — без проблем, ввиду чёткого разделения пространств имён.

Это показатель его убогости.

Блестящая строгость и всеобъемлемость аргументации.

Более динамично развивается, востребован.

Более динамичен и востребован твой задок малолетнего долбоёба. Развивайся лучше в этом направлении.

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

> (syntax->datum (expand-once #'(do-select ((id
            foo-bar
            (baz "xyz")
            list)
            table)
    (do-something id foo-bar baz list))))
'(with-rows
  ((row "SELECT id, foo_bar, xyz, list FROM table"))
  (match row ((list id foo-bar baz list) (do-something id foo-bar baz list))))

ну и заевалим для удобства, чтобы убедиться что все ок (with-rows транслируется в форму, которая биндит внутренним переменным список, на котором матчинг из теста нормально сработает):

(define do-something +)

(define-simple-macro (with-rows ([id:id e:expr] ...) body ...+)
  (let ([id '(1 2 3 4)] ...)
    body ...))

(do-select ((id
            foo-bar
            (baz "xyz")
            list)
            table)
    (do-something id foo-bar baz list))

->
10

хотя полезность сомнительна

Дело не в полезности. Просто с точки зрения схемы совершенно похуй что переопределять. Все идентификаторы равны. Можно и спецформы переопределить. И даже #%datum/#%app.

Но вернёмся к примеру: что делать с идентификатором list?

Что хочешь - то и делай.

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

Ну да. В этом смысл лексического скопа. Вполне нормальное и ожидаемое поведение.

Тогда как в «Lisp 2» — без проблем, ввиду чёткого разделения пространств имён.

Даже в lisp in small pieces указано, что возможность писать (list list) - скорее недостаток, чем достоинство.

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

(begin-for-syntax
  
  (define-syntax-class sid
    (pattern tid:id
             #:with id (if (identifier-binding #'tid)
                           (format-id #'tid "~a" (string-upcase (symbol->string (syntax->datum #'tid))))
                           #'tid)))
  
  (define-syntax-class binding
    (pattern (tid:sid str:str)
             #:with id #'tid.id)
    (pattern tid:sid
             #:with id #'tid.id
             #:with str #`#,(let ([s (symbol->string (syntax-e #'id))])
                              (string-replace (if (sequence-ormap char-lower-case? s)
                                                  s
                                                  (string-downcase s))
                                              "-" "_"))))
  
  (define (get-sql bstrs table)
    (~a "SELECT " (apply ~a bstrs #:separator ", ") " FROM " table)))

(define-simple-macro (do-select ((b:binding ...) table:binding) body:expr ...+)
  #:with sql #`#,(get-sql (syntax->datum #'(b.str ...)) (syntax-e #'table.str))
  (with-rows ([row sql])
     (match row 
       [(list b.id ...) body ...])))

(define-simple-macro (with-rows ([id:id e:expr] ...) body ...+)
  (let ([id '(1 2 3 4)] ...)
    body ...))

(do-select ((id
            foo-bar
            (baz "xyz")
            list)
            table)
    (list LIST))

->
(4)

Далеко не всегда выразительность определяется «бОльшей» декларативностью

Конечно же всегда.

Эти вещи вообще ортогональны

Нет. Применительно к написанию кода, декларативность - и есть выразительность. Ортогональны между собой: декларативность и функциональный стиль, декларативность и императивный стиль.

Фактически, ты сейчас объяснил всем

Все и без меня это знали.

что вся нынешняя функциональная братия — немощна, умерла или в нишах.

Скорее, в нишах. Ниши эрланга и камла известны, ниша хаскеля - исследования, т.е. «борщехлебание».

Гвидобейсик тут ни при чём совершенно.

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

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

И что? Это не беда. Особенности метапрограммирования. Мы ещё и порядок вычисления (фактически, семантику формы) не можем угадать, пока не посмотрим во что раскрывается макрос или пока не прочтём документацию. Это абсолютно нормально.

Кроме того, проблемы есть и в лисп-2, например, слот переменной-то перекрыт _будет_

Будет конечно. И от этого никуда не деться. Зато с пространством функций всё будет гладко — можно расслабиться и не думать о трансляциях имён и о ручной обработке подобной (весьма частой) ситуации. Конечно это не killer feautre, но крайне приятная штука.

Если же мы хотим, чтобы ничего не перекрывалось, то можно сделать:

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

покажешь аналог для CL

Хуйня вопрос, покажу. Но так делать нельзя. Это bad practice интроспекции окружения.

(defmacro with-rows% ((row qs) &body body)
  (declare (ignore qs))
  `(let ((,row (list 1 2 3 4)))
     ,@body))

(defmacro do-select% ((bindings table) &body body &environment env)
  (let* ((syms (mapcar #'(lambda (binding &aux (sym (binding->symbol binding)))
                           (if (or (variable-information sym env)
                                   (function-information sym env))
                               (let (($sym (symbolicate :$ sym)))
                                 (warn "transform identifier [~a] -> [~a]"
                                        sym
                                       $sym)
                                 $sym)
                               sym))
                       bindings))
         (fields (mapcar #'binding->ident bindings))
         (query-string (sql-select fields (binding->ident table))))
    (with-gensyms (row)
      `(with-rows% (,row ,query-string)
         (destructuring-bind ,syms ,row
           ,@body)))))

(let ((id "yoba"))
  (declare (ignore id))
  (do-select% ((id
                foo-bar
                (baz "xyz")
                list)
               :table)
    (+ $id foo-bar baz $list)))

; in: LET ((ID "yoba"))
;     (DO-SELECT% ((ID FOO-BAR (BAZ "xyz") LIST) :TABLE)
;       (+ $ID FOO-BAR BAZ $LIST))
; 
; caught WARNING:
;   transform identifier [ID] -> [$ID]
; 
; caught WARNING:
;   transform identifier [LIST] -> [$LIST]
; 
; compilation unit finished
;   caught 2 WARNING conditions

; 10

Мы ж ФП хотим, а не iterate.

Это ты хочешь ФП, а мне похуй на ФП. Я хочу поддерживаемые и выразительные решения. Поставить знак равенства между выразительностью и ФП может только объёбаный функциональщик, но в реальном мире дела обстоят под другому и всё сложнее.

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

Конкретно какой пример на CL написать, ткни пожалуйста. В той ссылке с примерами, что ты мне скидывал, всё — тривиальная лохня. Приведи действительный пример, где Clojure по выразительности (хотя бы) и поддерживаемости зарулит CL.

Мы ж ФП хотим, а не iterate.

Это ты хочешь ФП, а мне похуй на ФП. Я хочу поддерживаемые и выразительные решения.

Мы обсуждали здесь возможности ФП в CL, а не абстрактную х-ню из твоей головы.

Поставить знак равенства между выразительностью и ФП может только объёбаный функциональщик

Наверное «объёбаный функциональщик» это ты, потому что я написал что выразительность и фп ортогональны, для целого класса задач.

но в реальном мире дела обстоят под другому и всё сложнее

Расскажи о реальном мире, нео.

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

Конкретно какой пример на CL написать, ткни пожалуйста. В той ссылке с примерами, что ты мне скидывал, всё — тривиальная лохня

Тривиальная лохня, которую ты неосилил реализовать. Которая не интегрирована в стандартную библиотеку и не является распространенной практикой в мире CL. Попробуй еще раз, с N-ного раза осознать, что в clojure кое-что «уже есть и работает», а в CL «напиши сам», разрекламируй, перепиши компилятор и стандартную библиотеку, создай сообщество итд. Рациум подсказываем - проще и более выгодно использовать то, что уже есть, а не _переизобретать_ велосипед, ферштейн?

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

Да это примеры вообще все умозрительные, что тут приводить и так все очевидно. Даже на уровне как ты ее называешь «лохни» это более чем очевидно, зачем что-то усложнять для демонстрации простых истин?

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

Если спрашиваешь «в общем», то по поддерживаемости уже *везде* - банально сообщество больше, активное и вменяемое.

По выразительности в некоторых нишах весьма уделывает, например вебня, обработка бигдаты, сервера приложений, прототипирование - в случаях, когда нужны готовые и отлаженные java-либы, gui с frp-подходом и вообще как заменитель javascript.

А CL - устаревший монстр, узник стандартна и маргинального общества. В текущем виде никакого будущего у него нет - многословный (не хватает синтаксиса, синтаксис можно добавить, но это будет твой личный никому ненужный синтаксис), с хреновой пакетной системой (об этом знают, наверное, все лисперы кроме тебя), открытые реализации глючные и с наркоманским кодом, в котором нереально разобраться, CLOS не всегда уместна, часто избыточна и опять же многословна + хреново все с пространствами имен (как и везде в CL), стандартных message passing OO систем в CL нет, а те что есть требуют введения _синтаксиса_, чтобы не хуячить тонны скобок. Примитивная макро-система. Что я еще забыл? Неудачный коденейминг стандартных функций, раздутый стандарт.

Сам факт того, что тучи оголтелых лисперов хотят написать «свой лисп» уже о многом говорит.

Ну, и может ты мне покажешь хотя бы продакшн-риди веб-сервер на common lisp? Нет, а чего, за 30 лет не смогли написать? :)

Баттхёрт очередного говнаря Веньки с одними и теми же шаблонными, услышанными на дваче, якобы «аргументами».

банально сообщество больше, активное и вменяемое.

Эти трёх пунктов одновременно быть не может. Просто смирись с этим. Ввиду твоего восхищения python community этот бряк оставлю без комментариев :)

По выразительности в некоторых нишах весьма уделывает, например вебня, обработка бигдаты, сервера приложений, прототипирование - в случаях, когда нужны готовые и отлаженные java-либы, gui с frp-подходом и вообще как заменитель javascript.

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

А CL - устаревший монстр, узник стандартна и маргинального общества.

И чем же CL устарел, Вень? Тем, что в стандарте нет ленивых структур данных? И как отражаются «кандалы» стандарта на развитие сообщества и библиотек?

В текущем виде никакого будущего у него нет

Ну, конечно, Вень. Конечно же именно тебе, диванному кураретику, решать, у чего есть будущее и что должно умереть.

многословный (не хватает синтаксиса, синтаксис можно добавить, но это будет твой личный никому ненужный синтаксис)

Тут Веня выдал себя с головой, выдал всю свою гвидоссаную сущность. Часто именно «программисты» на Python рассуждают подобным, невежественным образом. Да будет тебе известно, Венюшка долбоёб, что выразительность решения в первую очередь определена соответствием семантики языка к решаемой проблеме. И именно лаконичность и гомоиконность синтаксиса позволяет сосредоточиться над проектированием самого важного — семантики. Да будет тебе известно, что любой синтаксис к s-expr-ам навесить очень легко и это дело последнее, конечное, часто необходимое лишь для передачи решения сторонним людям не причастным к разработке на Lisp.

с хреновой пакетной системой (об этом знают, наверное, все лисперы кроме тебя)

Пакеты CL более чем хороши, на самом деле. А если рассмотреть, например, «модули» Python, то CL пакеты просто божественны :)

CLOS не всегда уместна, часто избыточна и опять же многословна + хреново все с пространствами имен (как и везде в CL)

Вень, а если я тебя спрошу, что именно хреново с пакетами и пространствами имён, ты ведь мне не ответишь, правда ведь? Но ты постарайся :) Я очень хочу от тебя услышать ответ.

стандартных message passing OO систем в CL нет

А не расскажешь ли ты, чем отличается обычный «message passing OO», от CLOS методов с диспетчеризацией по одному аргументу?

Остальной твой пост поскипал, до тех пор, пока ты не ответишь на вопросы :)

В F# вроде как есть и ленивые вычисления и ленивые последовательности, кстати.

Есть, но это не делает F# действительно ленивым языком (как Haskell).

Но нужнее от этого он не становится.

А чем плох F#? Вполне себе годный современный ML под .net. Прекрасно, я считаю.

И что? Это не беда.

Это как раз беда.

Будет конечно.

Ну и все. Тогда смысл такого костыля, если он ничего не дает?

Зато с пространством функций всё будет гладко

Так в 99% случаев проблема с перекрытием переменных из одного пространства.

можно расслабиться и не думать о трансляциях имён и о ручной обработке подобной (весьма частой) ситуации.

Ты пойми - это проблема общелисперов и ими же героически решенная. ИРЛ ее нет. Никто не думает о трансляции имен и их ручной обработке. Потому что не бывает таких ситуаций, где это нужно.

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

Макросы как раз для этого и нужны. Хорошая макросистема как раз и позволяет работать со скопом так, чтобы «все было хорошо». Тем более тут мы новые переменные не вводим, а просто меняем имя.

Хуйня вопрос, покажу.

Не работает же!

(let ()
  (do-select% ((id
                foo-bar
                (baz "xyz")
                list)
               :table)
    (+ $id foo-bar baz $list))
    (defun id () 'yoba))

Пакеты CL более чем хороши, на самом деле.

Вот тут я поперхнулся чаем.