[C++?] Серьезный вопрос.

>вообще-то - (lambda ()) - это список

но не наоборот же

>вся должна быть написана на ассемблере x86 например :)

в смысле - IA-32? а зачем? в чём цимес?

> вообще-то - (lambda ()) - это список а что там думает subtypep меня не интересует :)

Вы путаете что-то...

> вся должна быть написана на ассемблере x86 например :)

Зачем?

> что-бы два раза: (def name) (def name) в одном модуле было правомерно и я бы имел бы доступ к двум разным сущностям

clhs: flet, macrolet, symbol-macrolet

за rebol спасибо

про ассемблер, большей частью шутка , но с намеком
1 система должна быть настолько простой, что ее _можно_ написать на ассемблере одним человеком за ограниченное время
2 система - это минимальное ядро для раскрутки, но уже там должен быть ООП

>> вообще-то - (lambda ()) - это список а что там думает subtypep меня не интересует :)
> Вы путаете что-то..

не список ? строка ? :)
скобочки есть, есть, слова в скобочках есть, есть = 100% список :)

еще поясню
хочу систему в которой (car (lambda ())) имеет смысл :)
и еще неплохо , что-бы ((const x1 x2) (arg1 arg2)) так-же :)

>> что-бы два раза: (def name) (def name) в одном модуле было правомерно и я бы имел бы доступ к двум разным сущностям
> clhs: flet, macrolet, symbol-macrolet

может быть :),

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

Некто Xenocephal утверждал что он сначала написал Fort, на форте написал Лисп, а на лиспе уже реализовал С. Типа это бутстрап с нуля для рандомной железки такой.

что-то вроде

ладно, замяли :)

> не список ? строка ? :)

Даже школьнику известно, что это отображение потенциалов конденсаторов в реальном мире.

:)

>может лисп начнем мочить ?

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

>как там на этапе компиляции узнать какие функции чистые и сделать их ленивыми?

а зачем?

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

P.S. на этапе компиляции, то есть НЕ в рантайме, где именно не важно.

>а зачем?

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

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

>работы с этим не найти

может поспорим? :)

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

Держи: http://www.lambdassociates.org/faq1.htm Это лиспоподобный язык со статической типизацией и выведением типов. Написан на Коммон Лиспе.

и ещё, как сделать свои проверки типов на этапе компиляции. например, аргумент функции должен принимать значения некоторых типов

(defun a (b)
  (declare (type (or integer string) b))
  b)

(a 1) => 1
(a "1") => "1"
(a 1.0) => The value 1.0
is not of type
  (OR INTEGER (VECTOR CHARACTER) (VECTOR NIL) BASE-STRING).
   [Condition of type TYPE-ERROR]

Всем спасибо за ответы.
Нашел для себя много интересной информации.
Ну и спасибо за искрометный юмор в отдельных постах! ;-)

(defgeneric fn (x))

(defmethod fn ((c cons)) t)

(defun test (x)
(declare (type (integer) x))
(fn x))

(test 1)

There is no applicable method for the generic function
#<STANDARD-GENERIC-FUNCTION FN (1)>
when called with arguments
(1).
[Condition of type SIMPLE-ERROR]

>Это лиспоподобный язык со статической типизацией и выведением типов.

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

>Написан на Коммон Лиспе.

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

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

>может поспорим? :)

В среднем, шансы того, что всё это бесполезно для тебя 99%. Никто в здравом уме не будет даже думать о чём-то при таких рисках.

>В среднем, шансы того, что всё это бесполезно для тебя 99%

чушь

>Никто в здравом уме не будет даже думать о чём-то при таких рисках

это тебе libastral подсказал? в рельной жизни оно оказывается так, что, как правило, умение пользоваться этими "никому не нужными языками" свидетельствует о хорошем уровне специалиста, и HR'щики (которые не тупые блондинки) это понимают и учитывают. меня спрашивали на интервью и про J, и про CL, и про Haskell - в Киевских конторах и одной Лондонской. я здесь же чуть не устроился на работу эрлангистом, и регулярно общаюсь с людьми, которые пишут на APL

и да, я применяю эти "бесполезные на 99%" языки на работе, и без них мне было бы несколько сложней

There is no applicable method for the generic function

#<STANDARD-GENERIC-FUNCTION FN (1)> when called with arguments

Потому что диспетчеризация generic фукнций происходит по классу, а не по типу.

(declaim (ftype (function (cons) t) fn))                                                                                                         
(defun fn (y) t)                                                                                                                                                                  
                                                                                                                                                                                  
(declaim (ftype (function (integer) t) test))                                                                                                                                     
(defun test (x)                                                                                                                                                                   
  (fn x))          

CL-USER>             
; in: LAMBDA NIL                                                                                                                                                                  
;     (FN X)                                                                                                                                                                      
;                                                                                                                                                                                 
; note: deleting unreachable code                                                                                                                                                 
;                                                                                                                                                                                 
; caught WARNING:                                                                                                                                                                 
;   Asserted type CONS conflicts with derived type (VALUES INTEGER &OPTIONAL).                                                                                                    
;   See also:                                                                                                                                                                     
;     The SBCL Manual, Node "Handling of Types"                                                                                                                                   
;                                                                                                                                                                                 
; compilation unit finished                                                                                                                                                       
;   caught 1 WARNING condition                                                                                                                                                    
;   printed 1 note                                   
                                                                                                                                               
                    

> There is no applicable method for the generic function

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

зы Я понимаю, что ты хотел указать на отсутствие типизации в Коммон Лиспе. Спасибо, но я знал.

> Не то. Типизация должна быть смешанная,

Ссылку-то открывал? Там мало того, что вывод типов заявлен мощнее, чем в Хаскелле, так ещё типизацию можно опционально совсем отключать.

> Ссылку-то открывал? Там мало того, что вывод типов заявлен мощнее, чем в Хаскелле, так ещё типизацию можно опционально совсем отключать.

Кстати, есть ли для CL какой-нить static checker наподобие pylint?

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

функцию можно полностью поменять в рантайме и что? - это не аргумент на самом деле.

> зы Я понимаю, что ты хотел указать на отсутствие типизации в Коммон Лиспе. Спасибо, но я знал.

Не, типизация там есть, только динамическая :)

> функцию можно полностью поменять в рантайме и что? - это не аргумент на самом деле.

Не функцию поменять, а специализацию дженерику. Разницу видишь?

> Не, типизация там есть, только динамическая :)

Ты понял, что я имел в виду.

> Не функцию поменять, а специализацию дженерику. Разницу видишь?

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

>Держи: http://www.lambdassociates.org/faq1.htm Это лиспоподобный язык со статической типизацией и выведением типов. Написан на Коммон Лиспе.

Ух ты, спасибо. Почитал, есть гарды, паттерн матчинг. Очень даже интересно =)

>Ух ты, спасибо. Почитал, есть гарды, паттерн матчинг. Очень даже интересно =)

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

> проект, увы, свёрнут - автору надоело быть программистом

а разве его не хотели переписать на python и clojure?

> Ух ты, спасибо. Почитал, есть гарды, паттерн матчинг. Очень даже интересно =)

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

>а разве его не хотели переписать на python и clojure?

ну, Тарвер высказал мысль, что продолжать писать Qi на базе CL не стоит, и что лучше подумать про какой-нибудь Clojure; но сам он этим заниматься не намерен. так что "хотели" - это самое то слово

А Лисп сейчас развивается или топчется на месте? Например, что появилось нового по сравнению с состоянием на 1997 год (есть у меня B-level course по Common Lisp этого года).

> А Лисп сейчас развивается или топчется на месте? Например, что появилось нового по сравнению с состоянием на 1997 год (есть у меня B-level course по Common Lisp этого года).

ANSI-стандарт языка не менялся. Группа инициативных юзеров начала проработку следующей версии стандарта (Cltl3) с целью немного подчистить его.

В остальном, жизнь кипит: появились мощные оптимизирующие компиляторы, много библиотек, в том числе и реализующие новые концепции в софтостроении (AspectL, ContextL). Очень много софта во всю MOP использует, веб цветёт и пахнет (http-серверы, фреймворки на продолжениях), объектные persistent базы данных. Даже оконные менеджеры и трёхмерные игрушки пишут (sdl, opengl, openal, физические движки). Классические вещи типа экспертных систем тоже делают (gbbopen).

>Даже оконные менеджеры

stumpwm вистнет, падает, роняет другие приложения и не доделан, а xmonad стабилен и готов к использованию.

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

то есть МП лиспа не способно на практике изменить этого?

>и да, я применяю

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

>и да, я применяю

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

> то есть МП лиспа не способно на практике изменить этого?

Это решаемо, конечно же не в рамках мп, а в рамках компилятора и средств статической проверки.

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

если программист не знает средств фп (haskell, ml) - это плохой программист.

если программист не знает средств ооп (java or c++, clos) - это плохой программист.

если программист не знает средств метапрограммировани (common-lisp) - это плохой программист.

если программист не знает средств декларативного программирования (prolog) - это плохой программист.

>Это решаемо, конечно же не в рамках мп, а в рамках компилятора и средств статической проверки.

А в чём проблема? Ведь макроэкспандер - произвольная программа, есть так же eval-when. Насколько я понял, то можно к слотам атомов аттачить любую информацию, а после полной загрузки в образ, перед компиляцией, её проверять. Вроде ни никаких теоретических преград, а на практике уже нереально.

Кстати, а есть ли лисп, который при макрорасширении является обычным лиспом, а в остальном это С с синтаксисом из символьных выражений?

>если программист не знает средств фп (haskell, ml) - это плохой программист.

>если программист не знает средств ооп (java or c++, clos) - это плохой программист.

>если программист не знает средств метапрограммировани (common-lisp) - это плохой программист.

>если программист не знает средств декларативного программирования (prolog) - это плохой программист.

Да, а ещё матан, графы, всякую дискретику, аи, и т.д.

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

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

Профит, еще какой.

Вот вам, почитайте человека. http://antilamer.livejournal.com/288854.html

1.

Я вот пишу на работе на джаве. Мой опыт использования полученных в результате изучения функциональщины знаний и умений, например, таков: - Роботоловилка - сложный вычислительный кусок кода; написана почти целиком на функциях высшего порядка (ФВП), но все их уродство скрыто в утилитном классе в паре дюжин нелаконичных, но кричаще-корректных примитивов и комбинаторов. Основная логика выражена через них буквально в нескольких строчках, читающихся как текст на английском языке. С момента написания в этом алгоритме не найдено ни одного бага. - Писал какую-то штуку для анализа HTML-страничек. Чуть не сдох, пока написал кое-как правильный обходчик DOM в определенном порядке с одновременным вычислением чего-то там хитрого в узлах. Было несколько почти одинаковых кусков кода с обходом и одновременным вычислением, и у всех были какие-нибудь разные баги в обходе: то атрибуты как-то не так обходятся, то текстовые узлы, то еще что. Мне это надоело, и я переписал все это на свёртки: отдельно - обобщенный обходчик как пара ФВП, отдельно - обобщенная свертка. Мигом пропали все до единого баги; код стал тривиален для понимания, и почти что на следующий же день оказалось, что код почти без усилий можно применить в соседней команде, где вместо DOM было что-то другое, но тоже древесное. (Примечание: Сегодня я расширил этот код еще раз под конкретную сегодняшнюю задачу, не трогая фреймворк - не представляю себе, как бы я это сделал, если бы он был написан не так, как сейчас - на основе ФВП - а как-нибудь «по обычному», как я бы его написал, если бы не был знаком с ФП) - Написал через ФВП кучку утилит для доступа к БД (более конкретно - примитивов и комбинаторов для Spring.JDBC: RowMapper/RowCallback/...); код сокращается местами в 2-3 раза; становится гораздо читаемей; этим хозяйством охотно пользуется вся немаленькая команда. - Товарищ из «Календаря» долго (несколько недель) мучился с противоречиями в их системе контроля доступа. Я предложил ему воспользоваться вместо неформальных рукомахательств - нотацией Пролога; я ему объяснил эту нотацию и семантику; мы посидели пару часов у доски с фломастером и придумали, вроде бы, хорошую концепцию. Тем же вечером он формализовал бОльшую его часть собственно на настоящем прологе (правда, не довел до запускаемого состояния; все-таки пролог за 1 день в мозги не впихнешь как следует). В течение короткого времени новая система (написанная, как и старая, на Java) была реализована; никаких проблем в ней не обнаружено.

Во всех случаях, как видно, знакомство с миром декларативного и функционального программирования приводило к самым положительным последствиям :)

Продолжение

[quote] Допустим, Вы программируете на С/C++/Perl/PHP. Что именно Вы сможете применить из ФП в рамках _этих_ инструментов?

- Функции высшего порядка и замыкания (пусть даже эмулированные с помощью указателей на функцию + void *data) и, во всяком случае, саму идею combinator library - Ленивые вычисления в какой-либо форме - Будучи знакомым с понятием зависимых типов, гораздо легче понять и эффективно использовать шаблоны С++ - Будучи знакомым с классами типов (typeclasses), я смогу эмулировать их с помощью dictionary-passing style (тем более в С++) и пользоваться приемами, типичными для классов типов. - Чисто функциональные структуры данных (на С/C++ - с подсчетом ссылок, за отсутствием GC) - Алгебраические типы - я смогу а) использовать их для моделирования предметной области и б) сэмулировать их с помощью абстракции конструкторов/селекторов/предикатов; разве что без pattern matching. - Будучи знакомым с prolog-style унификацией, я смогу (пусть и в редких случаях) сэмулировать ее и воспользоваться этим для упрощения какой-нибудь очень сложной условной логики. Я это уже один раз делал, после того как где-то час пытался написать логику красиво обычными if/else и понял, что без ошибок я ее не напишу - и, как обычно и бывает - написал минут за 15, и все сразу же заработало правильно. - Будучи знакомым с параметрическим полиморфизмом, я буду проектировать полиморфные функции по возможности параметрически полиморфными, что увеличит корректность моих программ и упростит рассуждения о них - Имея опыт программирования на чистом языке, я буду знать, насколько сильно чистота увеличивает корректность, и буду минимизировать и изолировать в своих программах побочные эффекты, что положительно скажется на корректности - Будучи знакомым с системами эффектов, я буду иметь возможность рассуждать об эффектах, производимых теми или иными процедурами в моей программе, что также положительно скажется на корректности моей программы и уменьшит количество "сюрпризов" и неявных взаимодействий в ней - Будучи знакомым с монадами или хотя бы ФВП, я смогу придумать хороший способ организации асинхронных вычислений - Будучи знакомым с continuations, я смогу при необходимости частично сэмулировать их с помощью getcontext/setcontext и реализовать себе зеленые нити или корутины. И, соответственно, смогу разглядеть задачу, где это действительно будет уместно - Будучи знакомым с понятием структурной рекурсии и с ее приятными свойствами (гарантированная завершаемость, очень легко рассуждать о структурно-рекурсивных процедурах), я буду по возможности использовать ее вместо общей рекурсии, что положительно скажется на корректности моих каких-нибудь сложных процедур обработки данных - Будучи знакомым с понятием хвостового вызова и с процедурой его удаления, я смогу не задумываясь и не ошибаясь оптимизировать некоторые рекурсивные процедуры - ... Во всех случаях благодаря тому, что я знаком с какой-либо ФПшной концепцией, я могу разглядеть ее полезность в той или иной задаче (в то время как незнакомым с ней придется самим ее изобретать или искать обходные пути), и, будучи знаком со способами реализации этой концепции, сэмулировать ее или воспользоваться ее основными идеями в своей задаче на своем языке.

[/quote]

>Профит, еще какой.

А если есть профит, то зачем этим делятся с остальными и пиарят на каждом углу? Кто же будет себя лишать профита. Тут возникает противоречие. Следовательно профита нет.

>>Профит, еще какой.

>А если есть профит, то зачем этим делятся с остальными и пиарят на каждом углу? Кто же будет себя лишать профита. Тут возникает противоречие. Следовательно профита нет.

Может, потом на работу хотят взять. :)

А ещё, человек - существо социальное. Если он увидел красивую штуку, он не может остальным не показать. :)

>профит просто несоизмерим с затраченными усилиями?

во-первых, не усилия, а fun. это ж, блин, интересно! а во-вторых, не было бы профита - не применял бы

>Если он увидел красивую штуку, он не может остальным не показать. :)

именно! :)

> Кстати, а есть ли лисп, который при макрорасширении является обычным лиспом, а в остальном это С с синтаксисом из символьных выражений?

А это вообще зачем? Конечно, такую бяку можно написать, но слишком разные у этих языков ниши, и насколько я знаю - такого нет. Есть то, что ты хочешь, но только для питона - CLpython.