Pull to refresh

Comments 93

с первого раза прочел как Фа-Диез… клиника…
UFO just landed and posted this here
Клево! Вот только… как то беспокоит, что этот язык принадлежит M$. Как бы эти возвышенные идеи не скатились к баблу…
А что значит принадлежит? Разрабатывается — да. Спецификации языка открыты.
Формально =) Но на практике, пользуются тем, чем удобнее. Например VS с .net'ом будут однозначно удобнее, чем сторонние разработки. А дальше известная история лицензированием, связностью продуктов и т. д. Хотя это их право, осуждения бесмысленны.
Полноценная интеграция с Visual Studio — это прекрасно! Радостно представляю себе отдельные модули на F# в проектах.
UFO just landed and posted this here
Стараюсь не путать =) Идея хорошая, но как я уже говорил: главное чтобы они не перешли определенную границу. Все почему-то не заметили в моей фразе сочетание «как бы».
К сожалению, не всегда удается им удерживать равновесие, примеров масса. Фишка в том, что если развитием (любого продукта) занимается огромная корпорация — неизбежны копромиссы между многими руководителями — и в результате замещается авторский стиль продукта на «среднюю температуру по больнице».
Ну давай по порядку. Вопрос простой.

… зачем понадобился еще один функциональный язык программирования в мировую копилочку? Чем он лучше того же Haskell? По виду сортировки — очень похож…

Вообще странно, хотя бы даже потому, что в разработке стандарта Хаскелла принимала публика из Microsoft Research Labs, или как их там.

Действительно интересно, какая там модель многопоточного программирования?

В моем питерском Политехе функциональное программирование вроде как изучали на примере Common Lisp, с отдельными примерами на Haskell.

Уже глубже я занимался этой парой языков для себя, Lisp — для работы в Emacs, Haskell — для всякого рода личных экспериментов.
На самом деле Пейтон-Джонс, создатель Haskell, потом перешел работать в Microsoft Research. Правда, F# делала немного другая команда. Разница с Haskell в данном случае в том, что F# — энергичный язык, соответственно, более производительный и пригодный для интеграции с императивным кодом. Про многопоточность — к сожалению не сразу, но модель есть, на основе монад.
Что значит «энергичный язык»? :)

Если про производительность, то знаменитый great language shootout говорит, что Haskell достаточно быстр; и может по меньшей мере ровняться на производительность языков с виртуальной машиной (aka .NET или Java).
Видимо, противоположность «ленивому языку» (см. википедию по фразам «ленивые вычисления» и «lazy evaluation»).
А-а-а-а, в этом смысле…

Да, знаю такую фишку, но только как это связано с производительность систем, построенных на языке? Зато Хаскелл компилируется вне виртуальных машин :)
> но только как это связано с производительность систем

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

> Зато Хаскелл компилируется вне виртуальных машин

Ымм… зато F# компилируется внутри виртуальных машин! :) (а .NET — это вообще виртуальная машина?).
ну… переполнение стэка будет вылезать в зависимости от реализации. По идее не должно. Вполне успешно и «лениво» мне доводилось читать огромнейшие файлы, потоки и прочие прелести безо всяких проблем.

Хотя производительность процесса ни с чем сравнивать, признаюсь, не довелось :)

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

А чем .Net — не виртуальная машина? Если я все правильно представляю, код компилируется в промежуточный код, потом в совсем низкоуровневый код, затем исполняется на общем бэкэнде, который и называется виртуальной машиной.Не зря ж Sun отсудила у Ms дикие бабки за спертую идею! :)
Конечно, производительность будет также в первую очередь зависеть от реализации :) Но в целом, сохранять вычисления «на потом» чуть более трудоемко, чем делать их сразу. Опять же в ленивых языках возникает необходимость в мемоизации, вычислениях с контекстом… что в целом требует больше памяти. Поэтому «при прочих равных» на энергичных языках получается более «естественный» с точки зрения императивного программиста код.

Однако основной довод в пользу энергичности F# — интероперабельность с императивным кодом.
>… зачем понадобился еще один функциональный язык программирования в мировую копилочку? Чем он лучше того же Haskell?

Haskell сам по себе. А F# — в составе .Net. Что позволяет легко интегрировать его с решениями на C#, VB, Boo, Nemerle и т.д.

Кстати, F# — это ml-язык, насколько я понимаю, так что его не с Хаскеллом надо сравнивать, а с тем же O'Caml.
почему же, его вполне себе можно сравнивать с Haskell — уже хотя бы потому, что оба позиционируются как ФП-яыки для real world programming. я бы даже сказал что такое сравнение будет весьма и весьма полезным
>оба позиционируются как ФП-яыки для real world programming

А… Ну, с этой точки зрения PHP и Си, например, близнецы-братья :) Оба — императивные языки для real world programming. И даже оба фигурные скобки для выделения блоков кода используют ;)
PHP — DSL (web-программирование), C — нет. так что пример аналогии сильно притянут за уши
Про области применения ничего не было. Было обобщение на тему ФП. Так вот, что PHP, что Си — то же самое, но ИП.

Но если так уж хочется сравнения языков широкого профиля, то пожалуйста — Си и Perl.
всё равно не то: Perl опять же не язык общего назначения,- он таковым не создавался и никогда так не позиционировался. в отличие от Haskell, в отличие от C#

точно так же как можно сравнивать Java и C# в контексте решения произвольных задач (или C++ и Eiffel/D), можно сравнивать и F# с Haskell

но вообще спор разведён бессмысленный и на ровном месте :) давайте просто сравним и посмотрим; можно и с OCaml заодно, и с SML.Net, и с Nemerle
Господи, ну возмите Паскаль и Java, например :D

>давайте просто сравним и посмотрим

Что конкретно? :)

У Хаскелла и ОКамла синтаксис различается очень сильно. Не меньше, чем у только что приведённых в качестве примера Паскаля и Явы. SML.Net не видел. Nemerle видел только краем глаза, насколько запомнил — синтаксис совсем далёкий и от Хамкелла и от Камла.

Кстати, Haskell создавался не как язык общего назначения, а как чисто академическое экспериментальное решение. В противоположность O'Caml'у, который именно для практического применения широкого профиля и разрабатывался.
Ну… Мне всегда казалось, что Haskell в определенной степени позаимствовал синтаксис из ML-группы языков.

Если поставить рядом сортировку Хоара на Хаскелле с Википедии и приведенную в статье F# версию, то получится похоже, вам не кажется? :)
а ещё он позаимствовал синтаксис у Miranda, KRC и Gopher. ну и у Божественного Языка Математики ;)

к вопросу сортировки Хоара поучительным будет прочтение данной заметки; элегантность и эффективность — зачастую сильно разные вещи
Божественный Язык Математики не так совершенен как haskell=), особенно если имеем дело с мат.анализом, но если вы говорили про алгебру, то я с вами полностью согласен.
да, именно алгебру. алгебру, матлогику и теорию чисел прежде всего — они транслируются в Haskell практически 1:1, что в нём и подкупает :) в современном промышленном программировании, увы, слишком мало математики — и Haskell-подобные языки в этом свете становятся очень и очень важны
кому-то в Microsoft Research было интересно сделать ML для .NET

это, в общем-то, вполне очевидное стремление

Haskell в другой стороне, он ленивый, а ML — энергичный, это фундаментальное отличие (я здесь не касаюсь вопросов того, что лучше), кроме того, он не чистый, на нём можно писать код с побочными эффектами

естественно, для industrial use — ML лучше, чем Haskell (и O'Caml, ещё одна разновидность ML — это доказывает)
Ну… Точных данных нет по, скажем, популярности OCaml в сравнении с Haskell; вот сейчас на каком-то блоге смотрел цифры по установке компиляторов OCaml, Haskell и Erlang в дистрибутивах Ubuntu/Debian. Вроде все на одном уровне.

А насчет «чистоты»… Разве для многопоточности не важна именно эта фишка? Не это ли позволяет так легко и хорошо распараллелить задачи? другие-то ключевые фишки, вроде функций высших порядков или лямбда-выражений уже давно есть даже в тех же Python или Javascript. Система же типов (Hidley-Milner, если память не обманывает) вроде как общая для Ocaml и Haskell.

Честно говоря, мне проблемой общей проблемой таких языков кажется некоторая невнятность отдельных концепций и местами — синтаксиса.
Система же типов (Hidley-Milner, если память не обманывает) вроде как общая для Ocaml и Haskell.
H-M в основе там и там, но системы типов всё же достаточно разные, чтобы принимать их во внимание при сравнении языков.
>> точных данных нет по, скажем, популярности OCaml в сравнении с Haskell

я точно знаю, что O'Caml используется в индустрии

Недавно мне довелось смотреть слайды, в которых разработчики Unreal Engine мечтательно размышляли Haskell, рассказывая при этом о минусах классических уже компилируемых языках — C++ и Java.

Да какая разница, в общем-то… Сейчас рулят динамические языки. :) За функциональными — будущее, но до этого будущего еще надо потерпеть :)
чудесный аргумент :) а я точно знаю, что в индустрии применяется Haskell — сам его применяю ;) да и не только я, конечно. и количество применяющих его компаний растёт
Вы не могли бы рассказать о практическом применении чуть поподробней? Очень интересно.

Для чего? Почему такой выбор? Есть ли выигрыш?
по работе я его применяю для реализации утилит статического анализа кода на C++; выбор такой оттого, что как инструмент Haskell подходит для этой задачи очень хорошо (да и готовых библиотек хватает); выигрыш — по скорости разработки и объёмам кода у меня держится отношение Haskell/C++ ~1/5-~1/10, т.е. соображения сугубо практические
>выигрыш — по скорости разработки и объёмам кода у меня держится отношение Haskell/C++ ~1/5-~1/10

Тогда Хаскелл сильно проигрывает даже PHP ;)

У меня на практических задачах трудозатрат на PHP-программирование выходит порядка на два меньше, чем когда-то на Си :D

1/5..1/10 — это против Си эффективность у чего-нибудь, типа D или Java без сторонних библиотек. Да и то, у Java эффективность повыше будет, наверное :)
Вы будете писать трансляторы на PHP? Вы очень храбрый человек

по поводу оценок — я мог бы привести конкретные задачи и предложить их решить :) ибо Ваши оценки выглядят, мягко выражаясь, необосновано. к слову, производительность C, C++ и D я тоже сравнивал, и отношением ~1/10 там и не пахнет. особенно в вопросах объёма кода (прежде всего семантически — по количеству сущностей; но и по LoC тоже)
Ну, я там PHP дальше приводил. Трансляторы на нём пишутся на практике. И пишутся много. И на порядок быстрее, чем на Си. Сам писал JBForth [тем более, есть с чем сравнивать — я писал Форты и на Си/Си++, и на ассемблерах x86 и PDP] :)

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

а вот сравнительный анализ как-нибудь провести — на одних и тех же задачах — будет очень интересно
О, Боже. Это уже по Фрейду :D

Читать как «Ну, я там Java дальше приводил. Трансляторы на нём пишутся на практике. »

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

>а вот сравнительный анализ как-нибудь провести — на одних и тех же задачах — будет очень интересно

Интересно. Но простые задачи будут не репрезентативны, ибо комплексные решения при оптимизации порождают разные классы небольших задач. А большие проекты реализовывать ради тестов — как-то накладно :)
Bal: приятно встретить собрата по разуму! Я в свое время писал FORTH на ассемблерах 8080 и Z80, а потом переносил на x86… Недавно был порадован функционально-стековым языком Cat.
Последнее, что я делал по этой теме — это реализация Forth'а на Java (но не с байткодо-генерацией). JBForth (GPL) интенсивно у нас использовался как скриптовый язык на MMORPG-сервере L2Fortress. Скорость на высокоуровневых определениях была что-то на уровне Перла.

Давно задуман вариант JBForth2 уже с полноценным байткодом и объектами, но в связи с долговременной заморозкой L2Fortress новый Форт тоже пока только на уровне задумки сидит :)

В принципе, уже JBForth не совсем чистый Форт. Идеология в целом та же, но вместо int'ов в стеке работает с объектами, те же строки вместо (addr u) используют нативные java.String. Нет единого кодофайла, каждое слово — отдельный объект. Зато слова можно произвольно удалять и перепределять, если не нужно — GC потом вычистит. Плюс прямые вызовы любых Java-конструкций их Форта. Удобная вышла штука.

JBForth2 же собираюсь ещё дальше уводить от классического Форта к Яве. Вплоть до того, что в планах введение типов, при чём с типизацией по Хиндли-Миллеру, динамическими типами и прочими вкусностями. Но тут очень важно соблюсти баланс, не потеряв гибкость Форта :)
>> Честно говоря, мне проблемой общей проблемой таких языков кажется некоторая невнятность отдельных концепций и местами — синтаксиса.

можете привести пример?
Ну… Классика… монады :) Вроде простая вещь, но понимается очень тяжело, тяжелее всего того, что было в императивном мире.

А про синтаксис… Ну возьмите сортировку на Питоне и рядом поставьте Haskell или OCaml. На Питоне сразу понятно, что и в каком порядке делается; а вот в функциональных…

Зато коротко и изящно, не так ли? :)

Поймите меня правильно! Мне нравится ФП, парадигма и то, что к ней прилагается; более того, свою пару тысяч строк на Лиспе и Хаскелле мне даже довелось написать. Но мир требует простоты. От технологий требуют простоты.
про сортировку — это ни разу не преимущество

на питоне мы говорим «как» мы это делаем, описываем процесс, порядок

на Haskell — «что» мы делаем, описываем суть, смысл
>Разве для многопоточности не важна именно эта фишка?

Это очень важная и полезная потенциальная фишка чистых ФП. Увы, пока только потенциальная :)
ML для .Net уже есть, называется SML.Net; F# это скорее Caml для .Net. ну или кастрированный OCaml для .Net, кому как ближе

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

по теме ленивости читать в обязательном порядке эту статью
На самом деле есть некоторый позитив в том, что возвышенные идеи «скатываются к баблу». Бабло — оно движет миром, а нам — сторонникам возвышенных идей — остается только радоваться тому, что наконец-то именно в возвышенные идеи стали вкладывать бабло. Иными словами, можно только радоваться тому, что МS обратил существенное внимание на функциональный подход!
Сначала вкладывают, а потом извлекают. Главное только палку не перегнуть.
Очень интересно, продолжайте, пожалуйста.
Имхо неплохо было бы включить в курс статей доступное разъяснение функциональных терминов (кэрринг и прочее). Оно от языка, конечно, не зависит, но глупо учить язык, не понимая чётко его идеи.
Кстати, а как у функциональных языков с обновлением? В смысле решена ли проблема с обновлением официалього кода программы, если клиент внес какие то изменения в код?
собсно… а зачем клиент будет вносить изменения в код? и кто ему его даст, если на то пошло?;))
Абстрактная ситуация:
есть открытый framework, есть стандартные библиотеки (или решения на нем). Клиент купил и использует эти решения. Но как известно необходимую гибкость предусмотреть заранее нельзя, поэтому клиент изменил часть кода одной из библиотек под свои нужды. Стандартные библитеки обновились, как обновить их клиенту?
Императивность, как я знаю на этом ломается. А функциональность?
>Абстрактная ситуация

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

Если это открытая лицензия — то клиент просто (если захочет простой жизни в будущем) отдаст изменения разработчику и в будущем получит новую версию в том числе и со своими изменениями.



В общем, ситуация на практике очень распространённая, а не абстрактная, и успешно решаемая в рамках любых языковых парадигм :)
Абстрактной я ее назвал, чтобы не возникали ненужные привязки к конкретным ситуациям =) Например, не важно какая лицензия, купили коммерческую или свободную взяли. Не важно кто будет изменять — разработчик или покупатель.
Суть в том, что у клиента (конкретный компьютер) должны быть свои модификации программы _произвольной_ гибкости. Это значит, что может быть затронут любой кусок программы. Если в официальную версию программы вносить изменения под каждого клиента (их могут быть тысячи + (изменения противоречат друг другу), программа рухнет. Если каждый изменяет у себя — он не сможет обновиться.

Действительно, это встречается повсюду — но я нигде не видел нормальных решений. Начиная от 1C, заканчивая Oracl'ом.
Хм… Честно говоря, я вообще практически не вижу решения этой проблемы.

Можно было бы привести в пример (да, опять, и опять, и опять, простите уж :))) ) Емакс, как систему абсолютной индивидуальной настройки… Всем она хороша, но большинство пользователей, даже профессионалов, все же предпочитает такой власти над инструментом некое усредненное подмножество возможностей.

Ну так вот… Там сердце — маленькое ядро-интерпретатор на Си, а все остальное довешивается разработчиками на Лиспе. А этот самый лисп, в свою очередь, крайне легко модифицируется, заменяется и преобразуется всякими хаками, которыми обмениваются любители емакса.
Я тоже не вижу ;-) Но я не очень хорошо знаю функциональное программирование. Поэтому подумал, что если там есть способы решения, кто-нибудь из профи по этому делу может подкинет пару мыслей.

ИМХО, функциональность дает возможность проще оборачивать стандартные «функции» (или выводить их в отдельные процессы). Еще наверное, имеет смысл смотреть в сторону монад.
«Ведь известно, что функциональное программирование не слишком используется в индустРиальном программировании!»
Исправьте, пожалуйста.
хотелось бы код для эффективной реализации сортировки Хоара, сравнимой по произовительности с императивным эквивалентом

ну и сравнение F# с OCaml и SML (SML.Net) также весьма не помешает

насчёт энергичности и производительности, к слову, чушь; было бы очень интересно посмотреть на примеры выигрыша F# над Haskell в производительности по причине энергичности первого и ленивости второго
Ждем продолжения. Особенно про многопоточность интересно. Ещё подсвечивайте код, пожалуйста.
Я буду повторять свой вопрос вновь и вновь… Зачем нужен еще один туториал? Какова его целевая аудитория? Есть книги, есть туториалы, есть Planet F# в конечном счёте…
Нельзя научится языку и уж тем более нельзя «подсесть» на язык читая какие-то статьи… К пониманию языка, к зависимости от него можно прийти лишь через постоянное его практическое применение.
Познакомиться с языком можно с помощью таких статей. Книги читать времени нет, особенно когда не знаешь «а нафиг оно тебе»…
Удивительный факт: познакомится с языком можно с помощью Википедии и дальше по ссылкам.
Можно найти множество весьма познавательные вещей типа: основные особенности, родственные языки, интервью с создателями, видео-туториал, обычные туториалы и т.д.

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

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

Я бы вообще никогда и ничего не узнал об F# просто потому, что принадлежу к другой ОСевой тусовке :) А так — представление определенное имею.
а Википедии будто бы нет ни авторов, ни способностей, ни чего такого…


так я и не призываю на Википедии останавливаться… Я призываю быть активным, т.е. писать код на изучаемом языке, потому что только так можно язык прочувствовать и понаступать на скрытые грабли.
Статьи по ФП на ресурсе типа хабра можно условно разделить на три категории:
1) Пропагандистские — людям хочется донести до широкой аудитории, как X круто и прикольно. Обоснование крутости прилагается, плюс минимум знаний, чтобы любознательный читатель мог запустить REPL и написать быструю сортировку. Таких статей большинство.
2) Tips & tricks — как красиво решить на вашем любимом ФЯП конкретную проблему.
3) Информационно-новостные — а-ля «вышла новая версия Erlang/OTP» или «SPJ в прошлые выходные прикрутил к GHC такое, что ого-го».
Не вижу причин, почему бы им не быть :-)
Я не понял куда в этой классификации относятся туториалы.

Вы поймите, я обеими руками за «обоснование крутости» и просто неистово желаю узреть статью «Tips & tricks», в которой бы кто-то поделился своим реальным опытом использования ФП для написания чего-то реального, а не примера «смотрите как круто можно отсортировать список, а вот как с помощью foldr перемножить его элементы». Может я читаю не те блоги? Ведь действительно есть же реальные проекты с использованием функциональщины (например, есть eDonkey-клиент написанный на O'Caml'е). Информационно-новостные тоже интересны, если они с деталями… Компиляторное искусство, искусство дизайна языков программирования — это поистине неисчерпаемые области…

Почему же всё сводится к какому-то «ликбезу»?

> Я не понял куда в этой классификации относятся туториалы.
Думаю, к первым. Просто туториал — это проторенная дорожка. Уж лучше так, чем ничего.
Компиляторное искусство, искусство дизайна языков программирования — это поистине неисчерпаемые области…
И кому, как не вам, писать здесь на эти темы :-)
статей второго типа вот что-то не видно, а жалко, хотелось бы имеено их
Буду рад ссылке на русский туториал или книгу о F#
Ну вот смотрите, что я нашел: msdn.microsoft.com/ru-ru/magazine/cc164244.aspx
В википедии есть ссылка на старое интвервью с Syme.

p.s. вообще я из тех странных людей, которые считают английским универсальным (а потому обязательным) языком для программистов.
есть программисты, которые познают английский язык в ходе изучения в университете.
и после университета еще несколько лет его активно шарахаются.
поэтому приходится стоять рядом с тем же msdn'ом и по-русски пересказывать им всё что там написано, иначе информация просто не будет прочитана никогда.
имею несколько примеров.
Ну а я из тех людей, у которых скорость усвоения материалов на русском языке >> чем на английском, и думаю я пока ещё на русском языке и излагаю свои мысли сотрудникам тоже на русском языке. Хотя без проблем могу читать и английскую (и не только) документацию.
Обогнали Вы меня. Я пишу цикл статей по F#, но идёт небыстро.

Что ж, буду догонять. :)
А ссылкой поделитесь?
Ссылки пока нет — для харбра же и пишу. :) 2 первые статьи готовы, но надо хотя бы ещё пару написать, чтобы получился цикл.
Расскажите для императивщиков как в функциональном стиле решаются вопросы банального CRUD из БД.

В императивном стиле — понятно — есть DAL менеджер какой-нить, дергаем из него конкретный метод с конкретными параметрами — получаем в виде инстанса набор данных из БД.

Как это же действие реализуется в ФП на примере F#?
Не думаю, что эту задачу эффективно решать на ФЯ. Я для этих целей использую стандартные средства ADO.NET, с случае, когда структура БД имеет небольшой размер (около 6 табличек), то на этапе разработки вообще отказаться от БД, об этом я написал в заметке Разработка снизу-вверх и базы данных.
Ну, частный случай, адо.нет ( кстати а адо нет вы используете с датасетами ??? Почему тогда не линк2сиквел? ) и пр…
Получается в таком случае ФП решает только ограниченный спектр задач, да и то, которые по большей части — наукообразные. Ничего не могу сказать, решает эффективно и эффектно.
Но встает вопрос применимости к серьезным проектам…
Держать двух программистов (ФП+ИП) или ставить доп компилятор\модули, иметь ассорти из очень разных подходов. Думаете это правильный подход при разработке более-менее серьезных систем, рассчитанных на длительную поддержку\изменения?

Как решается вообще проблема хранения (и доступа к) каких-то данных, которые нельзя уместить в десяток списков в памяти

Я ничего не имею против ФП, более того мне очень интересно читать такие вещи (и на рсдне читал про фп, да и линком пользуюсь потихоньку), но почему-то каждый раз я чувствую запах сферического наукообразного коня в вакууме…
Слышится подход а-ля «Да, „мы“ (ФП) умеем решать некоторый класс задач очень красиво, а все остальное — недостойно нашего великого внимания».

PS я очень хорошо понимаю взаимную интегрированность LINQ (и query comprehension) и C#. Ее прикладной смысл очевиден и понятен. Но без самого шарпа — оно висит в воздухе. Это получается что чистые ФЯП — тоже висят?
В ФП как раз хорошо решаются проблемы доступа к данным за счет наличия ленивости. Сами данные подменяются функциями доступа, затем из «обычного» на вид описания строиться цепочка функций обработки, которые затем перелопачивают данные без необходимости размещать их в памяти. Внутри Майкрософта на F# успешно решаются такие задачи с огромными объемами данных!
Спасибо за статью. Не приходилось сталкиваться с F#, но, думаю, язык интересный.

> Преподавали ли вам функциональное программирование в вузе?

Да, в ГУАП'е (питерский универ аэрокосмического приборостроения) практическую часть ФП преподают на Common Lisp'e.

P.S.> прошел по ссылке — blogs.msdn.com/sos/, и понять не могу — что это за мой сайт? Вроде не было таких у меня. =) Вспомнил Вас, мы еще ВКонтакте один раз встречались на почве «Двойного тёзки» ;)
Функциональные языки мне не преподавали в ВУЗах и я их не использую.

У меня к вам вопрос. Дело в том, что для меня достаточно важен синтаксис языка. Мне нравится использовать удобные для себя языки т.к., в конце концов, мы не только пишем на этих языках, но и читаем код когда рефакторим, исправляем и корректируем старую функциональность. Было бы очень интересно посмотреть на примеры кода реализующих одну и ту же задачу на разных функциональных языках. Встречали ли вы что-нибудь подобное?
UFO just landed and posted this here
Нормально представлены :)

Достаточно, чтобы заметить: Perl, язык императивный, выглядит очень и очень лаконично — сравнимо с классическим Haskell-примером :)

Питоновское решение выглядит неожиданно некрасиво… Там, на мой вкус, надо бы разбить list comprehensions на пару строк, чтобы поприятней было.
UFO just landed and posted this here
1. Используйте ли вы функциональные языки программирования в работе? нет необходимости.
2. Преподавали ли вам функциональное программирование в вузе? да, но поверхностно, без фанатизма, пол года.
Кстати, может быть интересно сравнение решение «99 bottles» на Хаскелле:
99-bottles-of-beer.net/language-haskell-1613.html
bottles :: Int -> String
bottles n
        |n == 0 = "no more bottles"
        |n == 1 = "1 bottle"
        |n >  1 = show n ++ " bottles"

verse :: Int -> String
verse n
        |n == 0 = "No more bottles of beer on the wall, no more bottles of beer.\n"
                   ++ "Go to the store and buy some more, 99 bottles of beer on the wall."
        |n>0  = bottles n ++ " of beer on the wall, " ++ bottles n ++ " of beer.\n"
                   ++ "Take one down and pass it around, " ++ bottles (n-1)
                   ++ " of beer on the wall.\n"

main      = mapM (putStrLn . verse) [99,98..0]


На O'Caml:
99-bottles-of-beer.net/language-ocaml-510.html
let rec ninetyNineBottlesOfBeer  = function
     0 -> print_string "no more bottles of beer\n"
   | 1 -> print_string "1 bottle of beer on the wall. Take it down, pass 
it around\n" ; ninetyNineBottlesOfBeer 0
   | n -> print_int n ; print_string " bottles of beer on the wall. Take 
one down, pass it around\n" ; ninetyNineBottlesOfBeer (n - 1)
  in  ninetyNineBottlesOfBeer 99 ;

F#:
99-bottles-of-beer.net/language-fsharp-1348.html
#light

open System
open System.Text
open System.Drawing
open System.Windows.Forms

let theBottleSong =
   let strSong = new StringBuilder()
   let append (s:string) = strSong.Append(s) |> ignore
   for i = 99 downto 0 do
      if (i = 0) then
         append("\nNo more bottles of beer on the wall, no more bottles of beer." +
                "\nGo to the store and buy some more, 99 bottles of beer on the wall.")
      else 
         let x = i - 1
         let plural = if (i = 1) then "" else "s"

         append (sprintf "\n%d bottle%s of beer on the wall, %d bottle%s" i plural i plural);
         append "\nTake one down and pass it around, ";

         match x with 
         | 1 -> append "1 bottle "
         | 0 -> append " no more bottles "
         | _ -> append (sprintf "%d bottles of beer on the wall.\n" x)

   strSong.ToString()
    
let form = new Form(Width=500, Height=420, 
                    Visible=true, TopMost=true, 
                    FormBorderStyle=FormBorderStyle.FixedSingle, 
                    Text="99 bottles of beer presented in F#")

let textBox = new RichTextBox(Size=new Size(480, 350), 
                              Location=new Point(5, 5),
                              Text=theBottleSong)
form.Controls.Add(textBox)

let btnClose = new Button(Location=new Point(408, 360), Text="Close")
btnClose.Click.Add (fun _ -> form.Close())
form.Controls.Add(btnClose)

[<STAThread>]
do Application.Run(form)
<pre>

Perl (минимальная версия):
http://99-bottles-of-beer.net/language-perl-727.html
<pre>
sub b{$n=99-@_-$_||No;"$n bottle"."s"x!!--$n." of beer"};$w=" on the wall";
die map{b."$w,\n".b.",\nTake one down, pass it around,\n".b(0)."$w.\n\n"}0..98


Ещё на Perl можно так ;)
    ''=~(        '(?{'        .('`'        |'%')        .('['        ^'-')
    .('`'        |'!')        .('`'        |',')        .'"'.        '\\$'
    .'=='        .('['        ^'+')        .('`'        |'/')        .('['
    ^'+')        .'||'        .(';'        &'=')        .(';'        &'=')
    .';-'        .'-'.        '\\$'        .'=;'        .('['        ^'(')
    .('['        ^'.')        .('`'        |'"')        .('!'        ^'+')
   .'_\\{'      .'(\\$'      .';=('.      '\\$=|'      ."\|".(      '`'^'.'
  ).(('`')|    '/').').'    .'\\"'.+(    '{'^'[').    ('`'|'"')    .('`'|'/'
 ).('['^'/')  .('['^'/').  ('`'|',').(  '`'|('%')).  '\\".\\"'.(  '['^('(')).
 '\\"'.('['^  '#').'!!--'  .'\\$=.\\"'  .('{'^'[').  ('`'|'/').(  '`'|"\&").(
 '{'^"\[").(  '`'|"\"").(  '`'|"\%").(  '`'|"\%").(  '['^(')')).  '\\").\\"'.
 ('{'^'[').(  '`'|"\/").(  '`'|"\.").(  '{'^"\[").(  '['^"\/").(  '`'|"\(").(
 '`'|"\%").(  '{'^"\[").(  '['^"\,").(  '`'|"\!").(  '`'|"\,").(  '`'|(',')).
 '\\"\\}'.+(  '['^"\+").(  '['^"\)").(  '`'|"\)").(  '`'|"\.").(  '['^('/')).
 '+_,\\",'.(  '{'^('[')).  ('\\$;!').(  '!'^"\+").(  '{'^"\/").(  '`'|"\!").(
 '`'|"\+").(  '`'|"\%").(  '{'^"\[").(  '`'|"\/").(  '`'|"\.").(  '`'|"\%").(
 '{'^"\[").(  '`'|"\$").(  '`'|"\/").(  '['^"\,").(  '`'|('.')).  ','.(('{')^
 '[').("\["^  '+').("\`"|  '!').("\["^  '(').("\["^  '(').("\{"^  '[').("\`"|
 ')').("\["^  '/').("\{"^  '[').("\`"|  '!').("\["^  ')').("\`"|  '/').("\["^
 '.').("\`"|  '.').("\`"|  '$')."\,".(  '!'^('+')).  '\\",_,\\"'  .'!'.("\!"^
 '+').("\!"^  '+').'\\"'.  ('['^',').(  '`'|"\(").(  '`'|"\)").(  '`'|"\,").(
 '`'|('%')).  '++\\$="})'  );$:=('.')^  '~';$~='@'|  '(';$^=')'^  '[';$/='`';


Вообще, там много интересного :)
Sign up to leave a comment.

Articles