Посоветуйте «lisp»

racket или CL(sbcl)+Emacs+Slime

guile или любая другая scheme.

Если CL, то рекомендую sbcl.

посоветуйте

Советую CL+emacs+slime.

чтобы было много достаточно литературы

Из литературы, если с нуля, то лучше всего pcl.

и библиотек

quicklisp

чтобы можно было хоть что-нибудь полезное (для себя) сделать

Изучение лиспа полезно само по себе.

посоветуйте какой-нибудь «диалект»

для «потыкать в скобочки» можно наугад выбрать из CL, Racket, EmacsLisp, Clojure.

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

А что для тебя «полезное»?

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

Clojure

Библиотеки - вся Жава, беспредельность

Книги тоже есть. Почти все английские. Есть русский перевод «программирование на clojure».

посоветуйте какой-нибудь «диалект» или там «наследника»

будь мужиком - сделай сам :-)

А можно узнать чем полезно и кому?

Голосую за Racket.

1. Много литературы именно для обучения.

2. Чтобы получить работающую программу, достаточно набрать несколько строк. Например, www-сервер:

#lang web-server/insta
;; A "hello world" web server
(define (start request)
  (response/xexpr
   '(html
     (body "Hello World"))))

3. Больше возможностей, чем в CL.

4. Приучает к более аккуратному программированию.

Clojure

Больше возможностей, чем в CL

Каких именно?

А можно узнать чем полезно и кому?

Можно. Полезно тебе, для расширения кругозора. Ок?

Больше возможностей, чем в CL

Каких именно?

1. Continuations: call/cc, call/ec, call/comp, call/prompt

2. Нормальные модули. C rename-in, prefix-in, prefix-out.

3. контракты (это потенциально в CL возможно, но готового нет)

4. нормальный weak hash, weak box. Нормальный финализатор, который позволяет обращаться к удаляемому объекту. (может SBCL-specific, но всё же).

5. racket/gui с единым стабильно работающим интерфейсом для X11/Win/Mac.

6. Макросы. Ладно, этот пункт можно считать спорным. Возможно, вопрос вкуса.

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

Clojure + Leiningen + LightTable. Причина? Заработает без настройки и освоения.

1. Continuations:

cl-cont

2. Нормальные модули

Чем в CL не нормальные? Вполне практичные модули + надстройки для разруливания зависимостей типа asdl или quicklisp

3. контракты

Ну и много ли ты написал в таком стиле? Ну можно просто налабать макросов, проверяющих контракты, в том числе при компиляции.

4. нормальный weak hash, weak box. Нормальный финализатор

Это есть в большинстве реализаций.

5. racket/gui с единым стабильно работающим интерфейсом для X11/Win/Mac.

Есть биндинги.

6. Макросы.

Сам сказал что спорно. Вообще обильное применение макросов спорно.

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

Узкоспециально и неэффективно по сравнению с полноценным транслятором «с нуля».

cl-cont

Весьма кривой костыль.

Чем в CL не нормальные?

Всем.

Ну и много ли ты написал в таком стиле?

Вполне ок стиль. Согласно style guide ракетки вообще всегда надо контракты писать.

Ну можно просто налабать макросов, проверяющих контракты, в том числе при компиляции.

Это весьма нетривиальная штука, особенно когда идет речь о high-order контрактах.

Узкоспециально и неэффективно по сравнению с полноценным транслятором «с нуля».

Это ничем не менее полноценно чем транслятор с нуля, просто есть изначальная поддержка в языке и определенная экосистема, чтобы все just works.

> cl-cont

Весьма кривой костыль.

Кривизна костыля как бы говорит нам, насколько он вообще кому-то нужен.

Согласно style guide ракетки вообще всегда надо контракты писать.

И что, пишут? Думаю, что нет.

когда идет речь о high-order контрактах.

Речь не идёт даже о том, чтобы кто-то писал простые контракты.

просто есть изначальная поддержка в языке и определенная экосистема

Какая такая, определённая?

Кривизна костыля как бы говорит нам, насколько он вообще кому-то нужен.

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

И что, пишут?

Конечно.

Речь не идёт даже о том, чтобы кто-то писал простые контракты.

Речь идет о том, что не получится у тебя «взять и налабать».

Какая такая, определённая?

Путем минимального допиливания у тебя сразу будет для твоего языка редактор с подсветкой синтаксиса, дебагер (и вообще нормальная обработка ошибок), профайлер, автокомплит, on the fly проверка синтаксических ошибок, интероперабельность с хост-языком и другими целевыми под-языками хост-языка. При этом ты сэкономишь усилия на разработка за счет наличия встроенных батареек, которые тебе помогут. Хотя если ты любитель лабать велосипеды на коленке под каждый чих вместо того, чтобы решать задачу - это для тебя неактуально, конечно.

++

Clojure

Говорю как схемер, предавший лисп ради Standard ML/OCaml/F#

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

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

Речь идет о том, что не получится у тебя «взять и налабать».

Речь идёт о том, что технически контракты можно прикрутить к CL.

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

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

Кстати как там всё это достигается, уж не через syntax-rules ли?

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

для расширения кругозора

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

По сабжу: Если уж рассматривать лисп как средство постижения программирования, глубокого понимания его, то lisp 1.5 User Manual. Современный лисп расширяет кругозор примерно так же как Алгол.

Современный лисп расширяет кругозор примерно так же как Алгол.

FAIL. Изучение Алгола и его истории действительно расширяет кругозор и помогает понять откуда растут ноги у современных языков. А ты не знал?

Говорю как схемер, предавший лисп ради Standard ML/OCaml/F#

Интересно было бы узнать, чем это вызвано, каковы мотивы?

В чем фейл? Я знал, дорогой КО, что ноги у современного быдлопрограммирования растут из алгола, в том числе и у быдлолиспов. Именно поэтому я и написал о расширении кругозора.

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

http://orthecreedence.github.io/cl-async/2012/11/07/missing-coroutines-in-com...

В общем, вся асинхронность (cl-async, cl-futures, weblocks, ...) в CL работает через костыль cl-cont. С соответствующими ограничениями по коду (это ещё стерпеть можно) и по скорости (iter внутри cl-cont'овского CPS проседает до 100 раз).

Ок, убедил.

асинхронность

А что, на ракет можно писать Ъ-асинхронный код? Т.е. как в JS:

setTimeout(function(){console.log("foo")})
console.log("bar")
//выводит
bar
foo

?

кроме Clojure мне кажется ничего интересного нет т.к. можно свободно взаимодействовать со всем кодом под JVM

Речь идёт о том, что технически контракты можно прикрутить к CL.

Технически можно писать все приложения на малболге.

Кстати как там всё это достигается, уж не через syntax-rules ли?

Нет.

Ок, где можно почитать про методологию применения продолжений, так, чтобы то же нельзя было бы сделать через рестарты?

Где можно прочитать про методологию применения рестартов так, чтобы то же нельзя было сделать через исключения?

С соответствующими ограничениями по коду (это ещё стерпеть можно)

До тех пор пока не понадобится много использовать ФВП.

Так чтоли?

(thread (λ ()
          (sleep 1)
          (displayln 'foo)))

(displayln 'bar)
->
#<thread>
bar
foo
> 

Clojure

Что такого есть в Clojure, чего нет в обычном нормальном лиспе?

> Кстати как там всё это достигается, уж не через syntax-rules ли?

Нет.

А как? Да я тёмный неуч.

чтобы то же нельзя было сделать через исключения?

В любой книжке по CL в главе про рестарты объясняется методология их применения и отличие от исключений, т.к. последние в CL тоже есть.

Совместимость с Java-миром, хорошая поддержка в бесплатных IDE.

В любой книжке по CL в главе про рестарты объясняется методология их применения

Ну ок, в любой книжке по схеме в главе про продолжения объясняется методология их применения

А как? Да я тёмный неуч.

Как что именно?

Совместимость с Java-миром, хорошая поддержка в бесплатных IDE.

В таком случае, зачем он нужен, если у нас уже есть Java?

в главе про продолжения объясняется методология их применения

Но там нет сравнения с рестартами, т.к. в схеме нет рестартов. Улавливаешь разницу?

Как что именно?

Путем минимального допиливания у тебя сразу будет для твоего языка редактор с подсветкой синтаксиса, дебагер (и вообще нормальная обработка ошибок), профайлер, автокомплит, on the fly проверка синтаксических ошибок, интероперабельность с хост-языком и другими целевыми под-языками хост-языка. При этом ты сэкономишь усилия на разработка за счет наличия встроенных батареек, которые тебе помогут. Хотя если ты любитель лабать велосипеды на коленке под каждый чих вместо того, чтобы решать задачу - это для тебя неактуально, конечно.

Я очень терпелив, спрошу ещё раз. Как всё это достигается. Ты сказал, что не через syntax-rules. А я тебя, значит, спрашиваю, а как тогда? В чем заключается технически это минимальное допиливание?

Или сразу так можно:

#lang racket
(require syntax/parse/define
         racket/stxparam
         racket/control)

(define-syntax-parameter thd #f)
(define-syntax-parameter cont #f)

(define-simple-macro (async body:expr ...)
  (begin (thread (λ ()
                   (let ([t (current-thread)])
                     (syntax-parameterize ([thd (make-rename-transformer #'t)])
                                          (reset body ...)))))
         (void)))

(define-simple-macro (await body:expr ...)
  (shift k (begin (thread (λ () (thread-send thd (begin body ...))))
                  (k (thread-receive)))))

;-----------------------
(async (displayln (+ 1 
                     (await (begin (sleep 1) 2)))))

(displayln 10)
->
#<thread:...ments\lor-so.rkt:10:10>
10
3

ЗЫ Капелька бояна http://imgs.xkcd.com/comics/lisp.jpg

perl + hop

Как всё это достигается.

Чтобы объяснить «как все это достигается», мне придется процитировать половину референса racket. Задай более конкретный вопрос.

Но там нет сравнения с рестартами, т.к. в схеме нет рестартов.

Правильно, нет, потому что никакой связи между продолжениями и рестартами нет. По-этому их никто и не сравнивает.

Да, но насколько я понимаю, в JS все исполняется в один поток. А то что Вы демонстрируете, это, может быть, не асинхронность, а асинхронный IO?

До тех пор пока не понадобится много использовать ФВП.

Никто не мешает ФВП тоже пропустить через CPS (взяв исходники и заменив defun на defun/cc). Но вот тормоза...

По-этому их никто и не сравнивает

Их все сравнивают в интернетах вообще-то, при сравнении CL и схемы. Просто в схеме нет рестартов, вот и не с чем сравнивать в мануале.

мне придется процитировать половину референса racket. Задай более конкретный вопрос.

Ну что ты валенком прикинулся. Я тебя конкретно спросил про syntax-rules, ты сказал - нет. Что нет? Есть другой способ описания синтаксиса? БНФ может быть? Или что-то ещё? Или ты не знаешь, как это конкретно делается в рэкете?

Никто не мешает ФВП тоже пропустить через CPS

Ну это офигеть уже просто.

Их все сравнивают в интернетах вообще-то, при сравнении CL и схемы.

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

Я тебя конкретно спросил про syntax-rules, ты сказал - нет. Что нет?

Нет, ничего из описанного никак не связано с syntax-rules. То есть совсем никак. Вообще.

Или ты не знаешь, как это конкретно делается в рэкете?

Что именно «это»? Я могу услышать конкретный вопрос вида: «как именно делается х» - где х не будет каким-нибудь «это» или «то», а будет конкретным объектом? Я не могу ответить, если ты не в состоянии сформулировать, что именно тебя интересует.

Да, но насколько я понимаю, в JS все исполняется в один поток.

В racket green threads, они реализованы внутри рантайма и не имеют отношения к системным потокам/процессам.

Просто в схеме нет рестартов, вот и не с чем сравнивать

В ракете нет, а в некоторых схемах есть: http://www.gnu.org/software/mit-scheme/documentation/mit-scheme-ref/Restarts....

Если очень хочется в Racket, то вот исходники: http://git.savannah.gnu.org/cgit/mit-scheme.git/tree/src/runtime/error.scm

Но вот здесь отсутствие поддержки в большинстве реализаций Scheme как раз говорит «насколько он вообще кому-то нужен»