А давайте обсуждать Scala

Підписуйтеся на Telegram-канал «DOU #tech», щоб не пропустити нові технічні статті

Есть у меня такое мнение:

Думаю из всех существующих функциональных языков, самым мейнстримовым станет Scala. У нее есть все шансы. Я бы купил акции если бы они у нее были :)

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

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

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

А так же есть такое не мое:

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

Сразу скажу, что с чистой как слеза будды функциональной парадигмой я встречался только в универе на лабах, писал на Lisp, Prolog, PostScript. И не скажу что был очень рад, так как без ООП и императивности тяжковато :) А вот с элементами из этих языков постоянно работаю, когда на повестке дня у меня python или javascript и с удовольствием применяю карринг, замыкания и т.п.

Но Scala :) - это так вкусно, что аж дух захватывает и императивность никто не отбирает. Java 3.0!

Обсуждаем за, против, нужно, не нужно. Кто-то может уже использует в проектах? Какие перспективы у этого языка? Легко ли найти работу и т.п.

👍ПодобаєтьсяСподобалось0
До обраногоВ обраному0
LinkedIn
Дозволені теги: blockquote, a, pre, code, ul, ol, li, b, i, del.
Ctrl + Enter
Дозволені теги: blockquote, a, pre, code, ul, ol, li, b, i, del.
Ctrl + Enter

Встретил мнение к которому пришел заочно эдак лет пять тому. Еще 8ой джавой и не пахло.

Back to the basics
Недавно после четырёхлетнего перерыва довелось снова немного пописать на Java (до этого практически эксклюзивно была Scala). Впечатления:

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

— Java 8 превосходна. Лямбды как настоящие, интероперабельность с предыдущим кодом с functional interfaces сохранена везде (и его сразу можно использовать правильно), множество мелких и приятных улучшений. Kotlin, наверное, не нужен.

— Чуть не забыл — streams! Они сразу позиционируются как серебряная пуля, и действительно решают массу проблем.

— Кода всё равно получается много — до компактности и изящества Скалы ещё далеко.

— Временем компиляции можно пренебречь. Я уже отвык от такого — а как этого не хватает...

— Всё работает хорошо.

Как-то грустно это, товарищи. В скале за прошедшее время уж можно было бы навести обещанный порядок.

А это значит, что можно к сущностям предметной области применять результаты алгебры. На моноидах, скажем
1. степень элемента считается за логарифмическое время
2. возможен инкрементальный пересчет свертки по отдельным элементам
3. возможно распараллеливание разных операций: параллельная свертка, пар подсчет префикса

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

у основы комунити мотивация основная — это что бы было не хуже чем в Haskel

У хаскеля есть некая чистота концепции, а скала — дикая смесь ООП, функпрограминга и хаков вокруг JVM.

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

В области компромисса между сложностью VS возможностями не составил мнения.
Но вот C++ сложен, однако доля рынка у него огромная (понятно, что в данный момент это следствие доминирования на рынке системного ПО, однако как-то же С++ выдавил конкурентов (тот же «простой» C) и удерживает позицию уже 15 лет).
---
Однако не могу сравнить Scala и C++ по сложности.

Ц++ 20 лет назад был намного более простым языком чем сейчас, достаточно сравнить первое и последнее издания мертвой птицы.

Которые позволяют делать ретроспективные расширения.
И, например, можно рассматривать неизменные legacy-сущности, как алгебраические объекты. Полугруппы там или моноиды. Т.е. можно прикрутить буквально всю алгебру.

Это пример алгебраических объектов из twitter/Algebird
«Of Algebirds, Monoids, Monads, and Other Bestiary for Large-Scale Data Analytics». Вот тут и фильтры Блума рассматривают зачем-то как моноиды.

Еще в скале благодаря implicit-ам можно реализовать Haskell-овские type classes.
“Type classes as objects and implicits”, Odersky + ... , Type classes were originally developed in Haskell as a disciplined alternative to ad-hoc polymorphism. Type classes have been shown to provide a type-safe solution to important challenges in software engineering and programming languages such as, for example, retroactive extension of programs. They are also recognized as a good mechanism for concept-based generic programming and, more recently, have evolved into a mechanism for type-level computation. This paper presents a lightweight approach to type classes in object-oriented (OO) languages with generics using the CONCEPT pattern and implicits (a type-directed implicit parameter passing mechanism).

Иван — я понимаю что у вас курсы по scala но можно было без некромантии обойтись

В Скале, в единственной из мейнстримовых языков, есть dependent types (Path-dependent types). Я так понимаю, что это сдвиг по одному из ребер лямбда-куба к Нирване.
“Types depending on terms, or dependent types. Imposing only this property yields λΠ (written as λP in the diagram), a type system closely related to LF.”

Нирваной и одновременно Верховным Богом является Исчисление Конструкций. Ему поклоняются верховные жрецы. В виду того, что на Скале этого реализовать нельзя, то и моему уму это непостижимо точно. По чем взял — потом отдал.

На прямой вопрос на stackoverflow: “Any reason why scala does not explicitly support dependent types?”
Автор библиотеки Shapeless ответил, что мол есть:
“Syntactic convenience aside, the combination of singleton types, path-dependent types and implicit values means that Scala has surprisingly good support for dependent typing, as I’ve tried to demonstrate in shapeless.
...
However, it’s often objected that Scala isn’t a ‘fully’ dependently type language because it doesn’t have dependent sum and product types as found in Agda or Coq or Idris as intrinsics. I think this reflects a fixation on form over fundamentals to some extent, nevertheless, I’ll try and show that Scala is a lot closer to these other languages than is typically acknowledged.
Despite the terminology, dependent sum types (also known as Sigma types) are simply a pair of values where the type of the second value is dependent on the first value. This is directly representable in Scala
...
Dependent product types (aka Pi types) are essentially functions from values to types.”

Потому как достаточно хорошо понять сам язык + базовые библиотеки которые делаю type-акробатику.

Еще это, в моем представлении, единственный язык в котором можно за год с нуля вырасти до 3к$ за год.
Но! Только если ты выпускник мех-мата или приклада.
Или аналогичного склада ума человек.

Даже в самом ядре языка зашита одна из моделей комбинаторов — Parser Combinators (scala.util.parsing).
А вот и статья Одерского — «Parser Combinators in Scala»

“The Magic Behind Parser Combinators”
— Intro to Parser Combinators
— How the Magic Works
— The Sequential Combinator
— The Disjunctive Combinator

Как понимаю я, в Scala можно строить разные комбинаторные логики. Выбирать базовые комбинаторы.
А вот финансы как раз и оказалось удобнее всего как предметную область описывать в виде комбинаторов.
«Composing Contrats: An Adventure in Financial Engineering», Simon Peyton Jones + ... — базовая статья от автора Haskell на представление финансовых контрактов на Haskell.
«Commercial Uses: Going functional on exotic trades» — описание DSL используемого в Barclays для работы с финансовыми инструментами (Haskell).
«Compositional specification of commercial contracts»
«Financial Domain-Specific Language Listing — большая подборка API / DSL на РАЗНЫХ функциональных языках для работы с финансами»

Есть правда и другие примеры.
Команда PhD фактически вшестером написала модель энергорынка Франции.
«Scala at EDF Trading. Implementing a Domain-Specific Language for Derivative Pricing with Scala».
Еще раз — !6! человек -> написали -> модель страны!
На Scala.

Ваня, ты тоже можешь написать модель страны на скала, даже в одиночку, вопрос в ее качестве.

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

Из сылки непонятно кто где и как использует эту модель. Ну и я думаю что такую модель можно и на джаве посчитать. Не в языке дело.

У них и статья с идентичным названием есть. Но свободной не вижу, все предлагают купить = dl.acm.org/....cfm?id=1668116.
Вот какой-то summary = www.scala-lang.org/.../node/3655.html.

Как бы это доказывает адекватность модели — реальному миру.

Еще раз — !6! человек -> написали -> модель страны!
Вы и правду не понимаете разницу между программированием мат модели и разработкой прикладного ПО? Или решили делать курсы по скале и начали разводить говномаркетинг?
.
Ну и не модель страны, а «модель энергорынка Франции» (и вполне возможно даже какой-то части это рынка)
.
UPD. И нафика некропостить?

Э! Куда хочу — туда и пишу!
Буду потрошить могилы.

Э! Куда хочу — туда и пишу!
От мне про вас много рассказывали, как про довольно разумного человека и классного спеца. К чему столько ваших усилий чтобы развеять этот миф?

Слушайте, дражайший, автор топика задал вопрос — «что народ думает про Скалу?». Я отвечаю автору топика. Чего Вы хотите?

Чего Вы хотите?
Чтобы в этом мире было меньше дерьма, или хотя бы на этом форуме.
Что вы можете сделать для этого? Ну например не спамить. (Если после нескольких лет преподавания вам все еще надо прибегать к спаму для раскрутки своей работы, это говорит о ее качестве)

Чего вы хороните годный топик раньше времени?

Из своего исследования рынка — на Scala платят как на Java везде, кроме 3 мест в мире — Кремниевой Долины, Нью-Йорка и Лондона. В Долине просто признали за язык и лабают стартапы. А вот в Лондоне и Нью-Йорке — пишут low-latency финансовые вычисления.
Зарплата в Большом Яблоке = 150к$-200к$ в год.

и что? я так сказал. ;)
уже не 2010 год, автор, что это писал вообще не в теме. F# - это наследник ocaml, так что нового там — поддержка .net. Интерактивность еще такая была в далеких 80-х в эпоху Schema.
И писать в императивно стиле на функциональном языке — это круто, язык то позволяет, но пусть пишет дальше на Си.

и что?

Да ниче, просто может вам бы было интересно.

Спасибо, я подумал, что это критикующая статья. :)

F# Enters Top 20 in Tiobe Index

Microsoft’s functional programming language F# is now the 19th most popular programming language for August 2011 according to the TIOBE Index. The language beat out other popular languages such as Scala, Clojure, and Haskell. TIOBE explains, “the recent rise in popularity of F# comes as no suprise. Apart from being a nicely designed language, F# is available in the latest version of Microsoft’s Visual Studio (2010)”.

Ни разу не конкуренты. Scala вбирается чаще всего теми компаниями, которые так или иначе сильно связанны с джавой и имеют уйму наработок/опыта под JVM. Так что область применения этих языков практически не пересекается. Scala под .NET не рассматривается ибо сейчас больше proof of concept.

Кстати, гугл провел бенчмарк, и скала выглядит вполне конкурентно: goo.gl/rPdcf

Использую Scala в продакшне уже второй год, и ничего кроме глубочайшего удовлетворения не испытываю. Сложность в убеждении ПМов и клиентов сильно преувеличена. Если вы проявите достаточно энтузиазма и характера, проведете несколько хороших презентаций и найдете единомышленников внутри организации, палки в колеса вставлять никто не будет (а если будет, повод задуматься — в правильной ли вы организации работаете).

Работу легко найти только в Штатах (там Scala во многих компаниях уже используется, как полноценная замена Java) и Англии (ситуация почти такая же благодатная, как в Штатах + большой местный рынок low-latency систем). В СНГ Scala используется в основном в стартапах, и тех немногочисленных организациях, где техническим лидерам удалось убедить «бизнес» в обоснованности решений.

На мой взгляд, основная проблема Scala на сегодняшний день — слабый маркетинг. Мартин Одерски (главный дизайнер Scala) — умнейший и интеллигентейший человек, но средний специалист в маркетинге. Представители Scala-коммьюнити вместо того, чтобы объяснять испуганным Java-кодерам то, какие бескрайние горизонты перед ними может открыть Scala, меряются умами с представителями Haskell-коммьюнити, доказывая, что могут делать на своем языке тоже самое, и даже больше.

Итого, размер коммьюнити и доля рынка будут постепенно расти, но существенный прорыв произойдет только в том случае, если в Scala-коммьюнити появится свой Гослинг, который до последнего вздоха и с пеной у рта будет доказывать свою правоту.

трафик в liftweb зашкаливает

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

Из недостатков — learnig curve конечно присутствует и он покруче чем в Java.

Функции высшых порядков(какое название пафосное придумали однако) и/или лямбды — это синтаксический сахар над джавовскими анонимными классами. Я сильно удевлен, что никто не реализовал препроцессор, который бы реализовал соответствующий синтаксис. К тому же лямбд вроде осталось ждать пару месяцев
Применимость паттерн матчинга очень узкая.

А почти все остальные фишки уже реализовано в джавовых библиотеках вроде functionaljava.org, и кто их хочет тот уже давно использует.

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

Джаву я тоже люблю и жду, но не то это пальто )

лямбды — это синтаксический сахар над джавовскими анонимными классами

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

// правда если в JDK8 замыкания кастрируют и скажут что так и надо — я не удивлюсь ;)

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

Ну вот потому и к final, что доступа к контексту нету.

P.S. Я посмотрел в текущий драфт (cr.openjdk.java.net/...a-state-3.html — да, клозуры в Java будут ненастоящие (то есть с ограничениями на использование только effective final variables контекста предков) и планируется их включить в JDK к концу 2012.

Ну вот потому и к final, что доступа к контексту нету.

тут проблема не в кастрированных closures, а в том что в момент выполнения closure локальнык контекст «предка» уже давно может не существовать.

ээээ --- я где-то слышал что java это язык со сбором мусора....

И? Варианта два, хранить все локальные контексты пока closures ссылаются на них, копируя все переменные из стека в динамическую память, что затратно по памяти, или хранить только элементы контекста которые были отмечены программистом как final. Джава выбрала второй, не вижу трагедии.

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

А в том, что выбор того или иного технического решения как правило не является трагедией, c вами трудно не согласится ;)

Выделение переменных на стеке — самое эфектовное в плане производительности, точка. Все остальное отстает, именно поэтому jdk пытается все что можно засунуть на стек с помощью escape analysis.

Я не понял мысль. Что сказать то хотел? Считаешь что на стеке память выделять менее производительно чем на куче? Что в дждк нету escape analysis?

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

И при этом было просто необходимо употребить слово «троль»?

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

Я тебя провоцирую? Помоему это ты ответил на мой комент текстом, который иначе как словом «вброс» назвать сложно.

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

Полноценный мутирующий контекст обещают в JDK8, как я понял, см стр 47 www.javaone.ru/...itriev_JDK7.pdf

нет — effective finals это как раз из project lambda который для JDK8

К сожалению я не сталкивался с термином

effective finals

Могли бы вы его пояснить.

Не совсем понял что «нет».

еffective finals это такие переменные, где либо в объявении стоит final, либо не стоит, но если его поставить — то программа все равно будет компилироваться. (Я так понял термин специально для project lambda придумали)

«нет» — в смысле нет полноценного мутирующего контекста в JDK8

// ну и понятно что исхитрится передав лишнюю ссылку можно и что все это не так уж важно)

Функции высшых порядков

Это всего-лишь дословный перевод известного понятия — «higher-order functions». Никто ничего не придумывал, и Америки не открывал.

К тому же лямбд вроде осталось ждать пару месяцев

Появление лямбд осталось ждать далеко не пару месяцев (особенно в энтерпрайзе!), и ситуации они существенно не изменят.

Применимость паттерн матчинга очень узкая

Смешно. Паттерн-матчинг — основополагающая концепция любого ФЯП. См. Erlang и Haskell.

А почти все остальные фишки уже реализовано в джавовых библиотеках вроде functionaljava

Никакая библиотека не сделает из Java мультипарадигменный язык, на котором можно будет писать «чистый» функциональный код. Систему типов пост-фактум более гибой тоже не сделаешь. Псевдо-функциональный код, написанный с использованием functionaljava, lambdaj и т.п. — трудночитаемая гора спагетти.

Это всего-лишь дословный перевод известного понятия — «higher-order functions». Никто ничего не придумывал, и Америки не открывал.
И? Это делает название менее пафосным? High-order functions такое же пафосное и безсмысленное, что такое low-order тогда?
Смешно. Паттерн-матчинг — основополагающая концепция любого ФЯП. См. Erlang и Haskell.
Расскажи как ты применяешь pattern matching в своей повседневной программистской жизни на примерах.
какая библиотека не сделает из Java мультипарадигменный язык, на котором можно будет писать «чистый» функциональный код.
Скала кмк не стримится навязывать чистый функциональный подход. Нужно ли в некрасноглазом программировании это делать, вопрос по которому компромис далеко не найден.
Систему типов пост-фактум более гибой тоже не сделаешь.
Пример можно, чего нельзя постфактум делать?
севдо-функциональный код, написанный с использованием functionaljava, lambdaj и т.п. — трудночитаемая гора спагетти.
Я очень опечален что у тебя получается трудночитаемая гора спагетти.

Это делает название менее пафосным? High-order functions такое же пафосное и безсмысленное, что такое low-order тогда?

Ок, здесь я возможно зафейлил, согласен что есть такая устоявшаяся терминология с higher-order и first-class функциями.

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

Хаха :) С functionaljava или lambdaj спагетти получается у меня, и у вас (у вас, мне кажется, в особенности, если такое недоумение вызывает фраза: «функции высшего порядка») :)

В качестве живого примера см. blog.tmorris.net/...onal-java-java

Пример можно, чего нельзя постфактум делать?

OMG. О типах высшего порядков я даже боюсь говорить :) А есть еще экзистенциальные типы, верхние границы типов, ограничители, более гибкая система ко-/контр-вариантности и многое другое, позволяющее более-менее полноценно заниматься type-level algerbra при дизайне библиотек.

Расскажи как ты применяешь pattern matching в своей повседневной программистской жизни на примерах.

Программируя на Scala в своей повседневной жизни, pattern-matching я использую повсеместно.

И? Это делает название менее пафосным? High-order functions такое же пафосное и безсмысленное, что такое low-order тогда?

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

недоумение вызывает фраза: «функции высшего порядка») :)

Спор был не о недоумении а о пафосности или непафосности названия.

Так примеры будут?

OMG. О типах высшего порядков я даже боюсь говорить :) А есть еще экзистенциальные типы, верхние границы типов, ограничители, более гибкая система ко-/контр-вариантности и многое другое, позволяющее более-менее полноценно заниматься type-level algerbra при дизайне библиотек.

Это и есть пример того, что система типов Java не потянет.

UPDATE: или вам нужны конкретные куски кода? :)

UPDATE: или вам нужны конкретные куски кода? :)

Нужны конкретные куски кода. Я не считаю аргументы вроде: «перечитай вот эти 10 томов ссылок» контруктивными.

Качетства хорошего аргумента: локаничность, наглядность, как ни странно правильность.

Вот 5 простых примеров сходу (больше писать пока лень): gist.github.com/923818

А это(примеры?) к чему если не секрет?

См. свой собственный вопрос выше, название гиста и комменты.

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

Попробую догадаться, в первом снипете ты пытаешься привести пример на свое утверждение: «Систему типов пост-фактум более гибой тоже не сделаешь.» И какое же препятствие мешает разработчикам jdk 1Х ввести structural type?


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

Вполне логично, что это ответ на вопрос в текущей ветке.

И какое же препятствие мешает разработчикам jdk 1Х ввести structural type?

Без лишних разглагольствований, прошу по каждому из 5-ти сниппетов аналог на Java.

Вполне логично, что это ответ на вопрос в текущей ветке.

Еще одна небольшая подсказка, вышеупомянутые несколько вопросов, я задавал _именно_ в текущей ветке.

Без лишних разглагольствований, прошу по каждому из 5-ти сниппетов аналог на Java.

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

Коментар порушує правила спільноти і видалений модераторами.

Коментар порушує правила спільноти і видалений модераторами.

Коментар порушує правила спільноти і видалений модераторами.


Хаха :) С functionaljava или lambdaj спагетти получается у меня, и у вас (у вас, мне кажется, в особенности, если такое недоумение вызывает фраза: «функции высшего порядка») :)

В качестве живого примера см. blog.tmorris.net/....onal-java-java

Такой пример речения программы на джава подойдет? ;-)

static boolean parse(String s) {
int l = −1;
while(s.length() != l) {
l = s.length();
s = s.replace("()", "").replace("[]", "");
}
return s.length() == 0;
}
Нет, конечно, потому что в задании требуется реализовать парсер (в идеале — комбинаторный, аналогично представленному, но и любой другой тип _парсера_ тоже сойдет).

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

Вот стековый вариант, все равно он намного читабельнее и понятнее того что там автор нарисовал:

static Map<character, character=""> ps = new HashMap<character, character="">();
static {
ps.put(’)’, ’(’);
ps.put(’]’, ’[’);

}

static boolean parse(String s) {
Stack<character> stack = new Stack<character>();
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (ps.values().contains©)
stack.push©;
else {
if (stack.size() == 0) return false;
char c2 = stack.pop();
if (ps.get© != c2) return false;
}
}
return stack.size() == 0;
}

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

Парсеры выделяют и анализируют токены, и строят деревья зависимостей, на основе входной последовательности, а вы, в своем решении, постепенно «убиваете» input, делая его непригодным к последующему использованию.

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

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

Если внимательно почитаете выше, речь шла о потенциале к расширению, которыми тривиальный replaceAll (который вы, судя по всему, бездумно скопировали из комментариев к статье) в отношении парсеров не обладает.

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

У тебя приступы бездумной телепатии?

Если внимательно почитаете выше, речь шла о потенциале к расширению, которыми тривиальный replaceAll в отношении парсеров не обладает.

1. Я данного утверждения вообще то не делал.

2. Было бы интересно посмотреть на сколько станут еще более монстрообразными и нечотабельными твои и так монстрообразные и нечитабельные примеры, если ты попытаешься указанный тобой «потенциал» использовать.

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

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

Я скорее имел в виду, что если заранее известно регулярное выражение, то это «навскидку — лексер». И утверждение — не критерий, работает не во все стороны, полезно, пожалуй, прежде всего для споров типа «ну какой же это парсер, когда всего лишь лексер» ;-)

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

В зависимости от того как расширять. Помоему товарищ там количеством строк кода меряется а не расширяемостью.

Расскажи как ты применяешь pattern matching в своей повседневной программистской жизни на примерах.

Вполне живой пример:

def toHexString(ba:Array[Byte]) = {
ba.map(_ & 0xff).map(x=>BigInt(x.toInt)).map(_ match {
case x if (x < 0×10) => «0» + x
case y:BigInt => y.toString(16)
}).foldRight("")(_+_)

}

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

«Намного проще» — это циклами? :) По-моему, тут уже проще некуда, я бы на С№ писал точно так же.

У меня нету уверенности что три мапа и фолд не преобразуются в четыре прохода по масиву, в место необходимого одного, bigint не нужен, можно вызвать например статический Integer.toHexString, или свой написать несложный для байта на крайняк.
И да, цыкл предпочтительнее, т.к. позволяет заюзать StringBuffer прозрачно, а что там foldRight в таких случаях сделает внутри, мне непонятно.

Хотя если не критично что потом проги тормозят и жрут память, можно и так писать конечно.

А ты не считаешь что это пример функционального программирования головного мозга?

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

У меня нету уверенности что три мапа и фолд не преобразуются в четыре прохода по масиву

Не преобразуется — я декомпилировал для интереса. Так что с производительностю всё ОК.

Оказывается можно :)

def toHexString2(ba: Stream[Byte]): Stream[Char] = {
if (ba.isEmpty) return Stream[Char]()
val v: Stream[Char] = BigInt((ba head) & 0xff).toString(16).toStream match {
case s if (s.size == 1) => ’0′ #:: s
case x => x
}
v append toHexString2(ba.tail)
}

toHexString2(Array[Byte](-0×3, 0×2, 0×73).toStream).foreach(print(_))

Такое будет работать даже в режиме чтения байтов из стрима с минимальными затратами ресурсов :)

Это далеко не с минимальными, посмотри реализацию соответствующего метода в apache commons что ли, прежде чем плодить тормозные велосипеды..

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

Берешь свои слова обратно: goo.gl/sGgMO ? В гугле забанили?

Это далеко не с минимальными

Обоснуй сначала. Затем продолжим.

Это же элементарно, ты создаешь лишьний бигинт на каждый символ, у тебя создается лишняя строка(а часто и две) на каждый символ, ты не эксплуатируешь тот факт, что тебе уже известен размер выходного масива (byteArray.size() * 2), а используешь стрим вместо этого, который очевидно имеет накладные расходы.

ты не эксплуатируешь тот факт, что тебе уже известен размер выходного масива (byteArray.size() * 2), а используешь стрим вместо этого

Использование стрима для данной функции следует рассматривать как «technical requirement». Поэтому некоректно в принципе сравнивать с алгоритмом для массива байтов фиксированной длинны.

у тебя создается лишняя строка(а часто и две) на каждый символ

Это не так. Во-первых она не лишняя, т.к. используется как источник для стрима. Во-вторых второй строки в принципе нет — ’0′ это character.

Это же элементарно, ты создаешь лишьний бигинт на каждый символ

Я могу принять такую «жертву» в потере производительности (lmao) для достижения простоты реализации.

Использование стрима для данной функции следует рассматривать как «technical requirement». Поэтому некоректно в принципе сравнивать с алгоритмом для массива байтов фиксированной длинны.

О уже начинается подгон условий под решение, хотя это было ожидаемо..

Это не так. Во-первых она не лишняя, т.к. используется как источник для стрима. Во-вторых второй строки в принципе нет — ’0′ это character.

ЧТо значит не лишняя если без нее можно обойтись? ПО поводу второй строки, то ’0′ + строка — это будет новая строка.

Я могу принять такую «жертву» в потере производительности (lmao) для достижения простоты реализации.

Нехилая такая жертва — в 26 раз, и не ты ли выше претендовал на «минимальные затраты ресурсов»?

О уже начинается подгон условий под решение, хотя это было ожидаемо..

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

ЧТо значит не лишняя если без нее можно обойтись? ПО поводу второй строки, то ’0′ + строка — это будет новая строка.

Там ’0′ #:: s.

Нехилая такая жертва — в 26 раз

А почему не 126? Ты успел написать бенчмарк или это чисто теоритические умозаключения?

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

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

Оо, а у меня хуже в 70-80 раз на масиве в 15 элементов. Код джава бенчмарка в студию, ты его с ключиком -server надеюсь запускал?

И сразу что бы два раза не вставать результаты «java -version» плиз.

Я брал среднее значение из 10 итераций откидывая макс и мин.

Тю, 10 итераций мало очень, там намного больше загрузка jvm занимает, попробуй на 10 млн итераций что ли.

+1
С аргументацией и матчастью у товарища серьезные проблемы.

А уж приводить в качестве примера сборище багов и паттернов ужасного дизайна, aka Apache Commons...

p.s. please, don’t feed the troll

А по сути вопроса сказать как обычно нечего? Ты тоже считаешь приведенную реализацию оптимальной по использованию вычислительных ресурсов?

Только что сравнил производительность, метод из jakarta commons работает в 26 раз быстрее чем предложенный нашими скалистами вариант, что как бы показывает что для некоторых языком молоть, не мешки ворочать.

Коментар порушує правила спільноти і видалений модераторами.

О, это твое последнее поделие тормозит в 240 раз больше ;-)

JVM 1.6.0_24 64 bit

def main(args: Array[String]) {
def genIn() = (1.to(10)).map((x) => {
128 — Random.nextInt(256)
}).map(_.toByte).toArray

run(10000, () => Hex.encodeHexString(genIn()))
run(10000, () => toHexString(genIn()))
run(10000, () => toHexString3(genIn()))
}

def run(times: Int, f: () => Unit) = {
var results = List[Long]()
for (i <- 0 to times) {
val started = System.currentTimeMillis
f()
val ended = System.currentTimeMillis — started
results = ended :: results
}
val avg = 1f * results.sum / results.size
println(avg)
}

0.02749725 // Apache commons
0.04349565 // Первая функция

0.06039396 // Третья функция

За “базар” ответиш?

Ок, отвечу, мой код:

def run(times: Int, f: () => Unit) = {
val started = System.currentTimeMillis
for (i <- 0 to times) {
f()
}
val ended = System.currentTimeMillis
println(ended — started)

}

def main(args: Array[String]) {
def genIn() = (1.to(15)).map((x) => {
25

}).map(_.toByte).toArray

run(10000000, () => Hex.encodeHexString(genIn()))
run(10000000, () => toHexString(genIn()))
run(10000000, () => toHexString3(genIn()))

}

export JAVA_OPTS="-server"
scalac -classpath ./commons-codec-1.5/commons-codec-1.5.jar ./hex2.scala
scala -classpath ./commons-codec-1.5/commons-codec-1.5.jar:./ hex2
Результаты:
12004
76533

303098

А теперь главное, следующая программа на джаве выполняется меньше секунды:

byte b[] = new byte[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
for(int i = 0; i < 10000000; i ++) {
Hex.encodeHexString(b);

}

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

А теперь главное, следующая программа на джаве выполняется меньше секунды

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

Результаты:

12004

76533

303098

Даже не смотря что ты «забил» масив лишь числами 25 у тебя явно не получилось 240 кратного превосходства.

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

скала не нужна

Тогда чё ты в этом топике так долго? :)

Даже не смотря что ты «забил» масив лишь числами 25 у тебя явно не получилось 240 кратного превосходства.

Только что написал вот так:

var p: Array[Byte] = Array(1, 2, 3, 4,5,6,7,8,9,10,11,12,13,14,15)

run(10000000, () => Hex.encodeHexString(p))
run(10000000, () => toHexString(p))
run(10000000, () => toHexString3(p))
И получил:
1033
75307
263628
Разница в 75 и 260 раз соответственно.

До этого я очевидно сравнивал твои скаловские эксперименты с джава программой, как я уже говорил.

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

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

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

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

Ну вот когда и если скала подрастет, что далеко не факт, тогда и поговорим.

Тогда чё ты в этом топике так долго? :)

Стебусь со скалистов.

Стебусь со скалистов

Стебетесь похоже по принципу: «в огороде — бузина, а в Киеве — дядька». Сначала просите привести пример использования паттерн-матчинга. Вам приводят, и вы говорите что он малопонятный. К слову, его можно упростить еще больше:

def toHexString(ba:Array[Byte]) =

(«" /: ba.map(_ & 0xff)){

case (str, x) if (x < 0×10) => str + «0» + x

case (str, y) => str + BigInt(y).toString(16)

}

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

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

Декларативную парадигму (и в частности Scala) выбирают совсем под другим причинам. В частности:

1) Намного меньший объем кода, и, как следствие, большая продуктивность и меньшее число ошибок;

2) За счет мощной системы типов, большинство ошибок можно обнаружить на этапе компиляции, а не в runtime;

3) Гибкость языка позволяет его расширять таким образом, что внешние библиотеки выглядят, как language features (взять, к примеру, стандартную библиотеку актеров);4) Деларативный канкаренси намного проще — в нем меньше вероятность сделать ошибку;

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

Опять же, кто говорил о производительности? (хотя, если уж и говорить, обратитесь к матчасти — parser combinators самые производительные).Каверкать имя — это вообще детский сад какой-то.

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

Вася(или как тебя там правильно), ты невнимательно читал ветку, Ивано(надеюсь правильное имя) написал кусок кода и с чего то решил что он «с минимальными затратами ресурсов», отсюда и пошли меряния бенчмарками, а вот твои коменты действительно в стиле «в огороде — бузина, а в Киеве — дядька».


1) Намного меньший объем кода, и, как следствие, большая продуктивность и меньшее число ошибок;
2) За счет мощной системы типов, большинство ошибок можно обнаружить на этапе компиляции, а не в runtime;

3) Гибкость языка позволяет его расширять таким образом, что внешние библиотеки выглядят, как language features (взять, к примеру, стандартную библиотеку актеров);4) Деларативный канкаренси намного проще — в нем меньше вероятность сделать ошибку;

Как ты наверное догадываешься по всем этим пунктам(кроме третьего) которые ты имел самоуверенность постулировать существует диаметрально противоположное мнение.

существует диаметрально противоположное мнение

Cуществует оно, судя по всему, только у вас, т.к.. вы имеете глупость оспаривать очевидные, научно-доказанные вещи :)Даже интересно, как вы аргументируете свою позицию, касательно п1, п2 и п4 :)

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

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

научно-доказанные вещи

Пруфлинк на научное доказательство?

аже интересно, как вы аргументируете свою позицию, касательно п1, п2 и п4 :)

Как ты наверное уже можешь догадаться лично тебе я ничего аргументировать не собораюсь, особенно с учетом того что твоих аргументов как то тоже не сильно видно.

Альтернативное мнение и факты — разные вещи. Я не исключаю, что у вас может быть альтернативное мнение, оспаривающее, скажем, законы физики :)Боюсь, что религиозный фанатик как раз таки вы, судя по тому, что именно вы всем с пеной у рта доказываете, что ничего кроме Java никому не нужно.

Пруфлинк на научное доказательство?

Я могу вам кинуть линк на описание типизированного лямбда-калкулус, научное обоснование STM в хаскеле и dataflow в Oz, и мн. другое, но вы все-равно не поймете, о чем там речь. Так что мой вам совет — не тратье время и деньги своих работодателей, придерживайтесь своих заблуждений, и пишите дальше код на Spring, Hibernate и Apache Commons ;)

p.s. Если, все-таки, очень хочется линков — вот книжечка по-проще (в штатах по ней на первых курсах computer science специальностей учатся): www.amazon.com/...g/dp/0262220695Там подробно описанно, что, как и почему ;)

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

Подсказка — открываешь гугл, вбиваешь в строку поиска

типизированного лямбда-калкулус, научное обоснование STM в хаскеле и dataflow в Oz

+ papers, и получаешь массу научных доказательств.

Я не верю что я там найду доказательство например такого твоего пункта: «Намного меньший объем кода, и, как следствие, большая продуктивность и меньшее число ошибок»

«Намного меньший объем кода, и, как следствие, большая продуктивность и меньшее число ошибок»

А вам на это нужно научное доказательство??! Здравого смысла не хватает, чтобы понять, что чисто статистически, на 10kloc шанс сделать ошибку больше, чем на 1kloc?! :) К тому же, писать 1kloc «несколько быстрее», чем 10kloc...

Очевидно что цыфры высосаны из пальца.

Вот вам простой пример — 50 линий на Java vs 1 линия на Scala: gist.github.com/936332

Ок, предположим ты нашел пример где скала выигрывает(хотя пример можно обсуждать конечно), ты сразу индуктивно распространяешь свой пример на всю реальность? Для меня вот такой пример является более репрезентативным: shootout.alioth.debian.org/u32q/scala.php

Опять 25.

Речь идет о ___продуктивности___.

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

Обсуждать, простите, что? Как можно объем java-кода уменьшить на 2.5 строки?

ты сразу индуктивно распространяешь свой пример на всю реальность

Таких примеров тьма.

Для меня вот такой пример является более репрезентативным:

Ой, да ладно. Вот только не надо притворяться, что вы занимаетесь low-latency программированием для трейдинговых систем, или экономите байты памяти, т.к. разрабатываете игры ;) Для вас будет показательным любой бенчамарк или диаграммка, положившись на которые, вы сможете сделать вывод, что java лучше всего существующего в галактике, и облегченно выдохнуть, с мыслью о том, что на кусок хлеба с маслом можно заработать не особо напрягая мозг :)

Коментар порушує правила спільноти і видалений модераторами.

Коментар порушує правила спільноти і видалений модераторами.

Коментар порушує правила спільноти і видалений модераторами.

хотя, если уж и говорить, обратитесь к матчасти — parser combinators самые производительные

Кстати, нарисованный мной стековый автомат работает за О(n), т.е. его обогнать в алгоритмической сложности нельзя, так что мат часть учи сам.

Каверкать имя — это вообще детский сад какой-то.

Васыль — это украинский вариант твоего имени, если ты вдруг не знаком с укр. языком..

Васыль — это украинский вариант твоего имени, если ты вдруг не знаком с укр. языком..

Увы, не знаком — я беларус. И, к слову, мы оба здесь пишем по-русски ;)

По аналогии с алгоритмом апачевского коммонс:

def dict = ((’0′ to ’9’).toList ::: (’a’ to ’f’).toList) toArray

def toHexString3(ba: Array[Byte]): String = {
val arr = ba.foldRight(List[Char]())((hd, l) => dict((hd & 0xf0) >>> 4) :: dict(hd & 0×0f) :: l).toArray
new String(arr)
}

для размеров масива меньше 16 работает даже быстрее

Нашёл небольшую проблему которая сильно влияет на производительность в данном примере. Вместо «def dict» в первой строке должен быть «val dict».

Тогда результат итерации 1млн раз на массиве длинной 16 байт (каждая итерация — новый масив случайных значений):

Для Apache Commons: 1.624

Для данной функции: 3.051

Так что разница в производительности менее 2 раз, что очень неплохо.

Звиздежь: snipt.org/xmYi
Разница в 10 раз.
995
68976

9890

Странные вы люди. Кодирование — вещь низкоуровневая, как бы известно что память надо экономить, поэтому с первого раза наиболее вероятно было бы что-то в стиле toHexString4
(см. pastebin.com/EkG6NPx7 ) Разница в 2 раза
Далее, если уже оптимизировать то мы знаем что foreach лучше заменить на ручной перебор (разница уменьшется до полутора (toHexString5) ). Для scala это проблема известная и думаю соответствующие оптимизации в компилятор рано или поздно встроят. Далее, замечаем что размер выходной строки у нас известен заранее и можно использовать массив символов (toHexString6).

Сюрприз — для идентичного алгоритма разницы во времени выполния нет, как и следовало ожидать.

5495 (apache-commons)
15798 (toHexString3)
10894 (toHexString4)
8090 (toHexString5)

5511 (toHexString6)

Я думаю что Ивано в своих попытках не пытался один в один содрать код из apache commons, а делал попытки написать эту функцию в типа функциональном скала стиле.

ну сигнатура то фиксирована, если мы одно и то-же сравниваем. А вобще это мне напоминает случае год назад, когда в fprog.ru опубликовали 4 более или менее реальных задачи. Обнаружили страшных разброс результатов абсолютно не зависящий от выбранных языков. В призерах были решения на Common Lisp, VBA и python.


Звиздежь: snipt.org/xmYi

Разница в 10 раз.

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

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

Я так понимаю некоторые функции твоего мозга блокируются ненавистью до функциональных языков программирования.

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

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

А из удаленных источников они стало быть поступают на вход твоей суперфункции минуя РЭМ? Гениально.

А из удаленных источников они стало быть поступают на вход твоей суперфункции минуя РЭМ? Гениально.

К счастью этот «генеальный» вывод сделан не мной поэтому прокоментировать его может лишь сам автор т.е. вы.

Давай свой код в студию, тогда и поговорим

Вообще-то свой код я не однократно предоставлял в этом топике. То что тебе этот код не нравится мне по барабану, потому как конструктива в твоих коментариях «0.0»

К счастью этот «генеальный» вывод сделан не мной поэтому прокоментировать его может лишь сам автор т.е. вы.

Та ну, а что тогда может означать фраза:

а поступают из других источников, часто удалённых.

Вообще-то свой код я не однократно предоставлял в этом топике. То что тебе этот код не нравится мне по барабану

Вообще то я как бы как раз и взял твой код, и сделал указанную тобой правку: поменял def на val , и выложил получившийся результат и это как раз тебе что то не нравится.

мне по барабану, потому как конструктива в твоих коментариях «0.0»

Понятно, слив засчитан.

Мне тоже нравится язык, но в его будущее я особо не верю, поскольку:
1) ФП требует профильного образования, «выпускники аграрных академий» эффективно не смогут работать.
2)

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

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

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

А для ХРа — это гемор при подборе спецов. Их просто мало, а толковых еще меньше, а в наших диких мексиках еще меньше.

4) Есть проблемы с совместимостью с джава-либыми (хибернейт, какая-то их константа или тип пересекался с зарезервированным словом, кажись «type»)

Кто-то может уже использует в проектах?

В промышленных вот только начну. В домашних использовал, вау-эффекта не получилось, но местами приятно.

Легко ли найти работу и т.п.

Замкнутый круг: мало спецов -> мало работы -> мало спецов.

А теперь «минутка троллинга на ДОУ»:

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

Пролог — это ФЯП? PostScript? :)

По поводу:

Пролог — это ФЯП? PostScript? :)

Про пролог даже не смешно :) Окститесь

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

Т.е. функциональный стиль программирование имеет, как это ни странно, подвиды. Существуют чисто абстрагированные языки, как Lisp, так и аппликативные, как PostScript. Он кстати относится к подмножеству аппликативных — к конкатенативным :)

Пример вычисления среднего арифметического на Lisp:

(lambda (ns) (/ (reduce #’+ ns) (length ns))

А так это будет на PostScript:

dup 0 exch {add} forall exch length div

Думаю, все понятно из примеров.

ФП требует профильного образования, «выпускники аграрных академий» эффективно не смогут работать.

Да, что бы писать на лиспе и других чистых языках.

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

Что плохого если человек пишет на джаве с синтаксисом скалы, когда нужно (удобнее, быстрее, понятнее) написать императивно?
Наверное я не правильно объяснил. Я имел ввиду, что большая часть люди (далеко не лучшие) будут лишь использовать «синтаксический сахар» языка, а не его возможности.
Например, var в C# — недоделанные юнлинги его тыкают куда только могут, что ухудшает код, имхо. Та же проблема с приведениями типов в шарпе, только она еще и на производительность влияет :)
Вот только что бы понять с объектом какого типа работаешь (какие методы можешь вызывать) надо углубляться в код который «порождает» этот объект или вызывать автокомплит и угадывать тип по его АПИ.
А главное что экономиться непонятно что вместо конкретного типа все равно пишется «что-то»,

чем-то напоминает объявление всех переменных через Object в Java или void * в C.

Підписатись на коментарі