Medium — http://book.realworldhaskell.org/read
Web — http://www.yesodweb.com/book
Предыдущий тонет здесь: >>1343135 (OP)
Хаскеллисты едят говно.
Какая всратая оп пикча.
есть шинибуть актульнее рил ворда?
Например вот, написал недавно.
как найти работу
Живее всех живых.
Можешь посмотреть выступления Пейтона-Джонса на эту тему одного из архитекторов хаскеля.
Но если смотреть не хочешь, то суть в том, что из совершенно ненужной академической хуеты без реализации I/O на первых стадиях язык стал использоваться в продакшене двумя с половиной Васянами, что определенно лучше нуля.
Скорее да чем нет
В скриптинге попизже петухона
Конкуретноспособен для написания серверлесс/микро сервисов
Общая архитектура все еще охуенна для написания любой ДСЛ шизофрении
Основные проблемы все еще провисающий низкий уровень и отсутсвие супер-топ-мейнстрим фреймворков
Из примеров
Пара случаев неведомой низкоуровневой хуйни https://github.com/haskell-servant/servant/issues/1167 https://github.com/haskell-servant/servant/issues/1165
Каким-то хуем сломанный haddock после 8.6+
Вебсокет протокол, например, вообще никак не описывает способы справления с крашем клиентов
Основная хачкельная network либа с сишным ffi просто ссылается на эту хуйню не предлагая никаких решений и хз как это решать
Еще рвут жопу бинарные либы отказывающие компелироваться из-за ссылок друг на друга
Имхо вызвано основным спонсированием микрософта который толкает свое фшарпное говно
Комунити нереально упоротое и если сможет превозмочь то возможно язык наконец-то выстрелит
Ну или окончательно утонет в ближайшие 5 лет
Сам нашёл, всратыши вы ёбанные
https://www.ohaskell.guide/
>Basics — http://learnyouahaskell.com/chapters
ГОВНО
>Medium — http://book.realworldhaskell.org/read
ДРИСНЯ
Web — http://www.yesodweb.com/book
НЕАДЕКВАТ
>Basics — http://learnyouahaskell.com/chapters
одна из немногих нормальных вводных книжек в языкнейм
>Medium — http://book.realworldhaskell.org/read
брошурка с хеллоуворлдами еще и аутдейтед
>Web — http://www.yesodweb.com/book
сам уесод кажется без задач
wai огонь
https://www.youtube.com/watch?v=vIk1e3RCPVk
https://tsar1997.blogspot.com/2019/10/blog-post_18.html
Когда-то давно ФП-элита из кодача жестко нагибала всяких макакенов: джяваиндусов, пыхоплеядеров, жс-школьников и прочий скам, но сильнее всех досталось крестоопущенцам, сидаунам и прочим байтоговнарикам: их загнали под шконарь на многие годы. Несмотря на то что эпицентром этого эпик тралинга был докач и частично pr/, на остальные помойки типа жеже, лора, жуика мода перенеслась так же. ФП-элита давно уже заскучала и разбрелась, но у всяких байтоговноедов заставших эти времена при слове ФП или хаски начинают болеть старые анальные раны.
>Приятны сердцу такие статьи, ибо помогают развенчивать культ скорости сишки, что паразитируют на умах людей уже многие десятилетия.
>развенчивать культ скорости сишки
>культ скорости сишки
>КУЛЬТ СКОРОСТИ СИШКИ
>РАЗВЕНЧИВАТЬ
А культ скорости света они не собирались развенчивать?
ФПетушки попытались наехать на С в области, в которой С безраздельно властвует, это ничего плохого не говорит об ФП или Хачкеле, только об ебанутости ФПетушков.
Еще добавь https://crypto.stanford.edu/~blynn/lambda/ для желающих понять как это работает под капотом хаскель сначала транспилится Core, который суть вариант System FC, затем в Spineless Tagless G-machine, затем в C--, а дальше от выбранного бэкенда зависит (https://gitlab.haskell.org/ghc/ghc/wikis/commentary/compiler/generated-code для любопытных) .
Да и вики у GHC весьма полезна https://gitlab.haskell.org/ghc/ghc/wikis/index .
Забыл докинуть: http://babel.ls.fi.upm.es/~pablo/Papers/Notes/f-fw.pdf
для желающих понять, что же такое simply typed lambda calculus, система типов Хиндли-Милнера (на которой был основан хаскель-98) и чем это отличается от System F.
Upd 3.
https://www.microsoft.com/en-us/research/people/simonpj/publications/
У мужика дофига полезных и интересных статеек по хацкелю в частности и фп в общем.
Ну тут по классике
https://homotopytypetheory.org/book/
Вопросы такие:
1. Какие ограничения в хаскеле есть в системе типов? Есть ли то, что есть в других более развитых языках, но нет в хаскеле? Я знаю про coq, idris, agda, но не знаю, чем принципиально их система типов отличается от хаскельной, мне кажется, что в хаскеле есть всё. Что-то слышал краем уха про HoTT/Martin-Löf TT, они сейчас востребованы?
2. Обязательно ли учить теоркат? Я сейчас читаю Милевски + какие-то конспекты лекций, откопанные в НМУ. Насколько хорошо её нужно знать?
>1.
https://www.youtube.com/watch?v=xcZ5yq_gG-4
>Милевски
Очень сомнительная мурзилка
>https://www.youtube.com/watch?v=xcZ5yq_gG-4
Что за фигня? Смотреть не стал, по превью сделал вывод, что не отвечает на мои вопросы
>Очень сомнительная мурзилка
Очень уважаемый человек у фпшников, кмк. Не Олег Киселев, конечно, но он и не занимается особо научной деятельностью. Книжка у него тоже топ, особенно благодаря стилю повествованию и упражнениям.
>читаю Милевски
>он и не занимается особо научной деятельностью
>Книжка у него топ
>Очень уважаемый человек
Очередной свидетель Теории Типов
Системы типов в языках программирования и теории типов это две большие разницы
На практике в 99.99999% случаев второе натягивается на первое для красивой записи в бесполезной формуле
Милевски уже лет 6 ездит со своими очень интересными лекциями имея на гитхабе пару хеллоуворлдов
только начал изучать хаселл, такой вопрос, имена должны быть такими уёбищно мелкими и непонятными? я пришёл из нормальных языков, где наоборот принято называть переменные как можно более понятно и длинно (но не слишком, тоже перебор, ну крч баланс соблюдать), а короткие имена типа a, b, c — это ошибка новичка тип, надо нормально писать мол userId, lastNumber и т.п. а не по одной-три буквы, или аббревиатура не дай боже (ну если только всеми принятые типа GUI, TCP). ну и вот.
пример паттерна из учебника: xs@(x:y:ys)
чо это? чо за иксэс? куда, почему, игрек, игрекэс, чо это значит?
я вот например так если напишу, на проекте допустим:
firstLetter :: String -> String
firstLetter all@(first:rest) = "First letter of string " ++ all ++ " is " ++ [first] ++ " the rest is " ++ rest
меня отпиздит тимлид? если я хочу нормальные названия переменных, не принято так?
смотрю вот исходники типа энтырпрайз проектов на хаскелле и там всё такое: r вместо responce, m вместо monad, a вместо param, bs вместо byteString, а были ещё x, t и b, которые я так и не понял чо значат из кода. У вас в хаселле буквы денег стоят, почему нельзя нормально писать?
я чото непонял?
спасибо заранее, аноны
ТАМ ВАКАНСИЯ!
> нормальных языков
Ну ты понял.
В математике вопреки здравому смыслу принято называть переменные одной буквой. Это сделано, чтобы как можно больше времени уходило на запоминание обозначений на самом деле - чтобы быстрее переписывать формулы при преобразовании. А сабж пытается всячески под неё косить.
> тимлид
Толсто.
> энтырпрайз проектов на хаскелле
Очень толсто.
Имена длинными имеет смысл делать только в том случае, если скоуп слишком большой и все эти i, x, xs перемешаются в одну кучу говна, в которой будет невозможно разобраться. В ФП принято делить все на как можно более простые функции (сама лямбда, в которой даже функций от многих переменных нет, к этому располагает), из-за чего скоуп получается маленьким и необходимости в длинных названиях нет.
m вместо Monad используют, потому что монады в хачкеле очень часто используются. Вон в Си тоже любят писать вместо pointerPizda pPizda, потому что все и так знают, что p -- это указатель, которые в Си повсюду.
Длинные имена для переменных которые что-то обозначают - userName, address итд
Для абстрактных переменных берут короткие общепринятые имена.
Ты же не жалуешься что в "нормальных языках" индекс в цикле обозначают буквой i, например?
Конкретно твой пример:
>xs@(x:y:ys)
xs - весь лист
x - первое вхождение
y - второе вхождение
ys - остатки
Просто общепринятые названия
Просто смотрел исходники сервера на хаскелле, но там и для не абстрактных переменных были короткие названия, типа r вместо response и чо-то ещё было. Некоторые я даже так и не понял что значат по исходнику — вроде для этого длинные названия и нужны, чтобы другой прогер (или ты через некоторое время), когда прочел этот код, понял что это значит. Ну, может, в процессе обучения поймаю "просветление" и начну понимать, не знаю, пока просто так.
Спасибо, ещё раз.
Может кто-нибудь ткнуть носом чего читать, чтобы заинстансить функтор к типу с рекорд-синтаксисом где в одном из полей функция лежит? Если убрать всё лишнее, то вот этот случай разобрать надо:
newtype Dvach b = Dvach { abu :: ( b -> String ) }
При этом
newtype Dvach b = Dvach { abu :: ( String -> b ) }
спокойно работает через
fmap f (Dvach pr) = Dvach ( \a -> f (pr a) )
Я уже часов 20 гугл рою, а ебучии статьи либо математику чистую сыпят, либо остоебавший уже пример "ну сейчас разберём функторы для Maybe', охуеть как вы теперь хачкель знаете".
newtype Dvach b = Dvach { abu :: ( b -> String ) }
не может быть функтором птому что b слева от стрелки
тебе нужен контровариантный функтор http://hackage.haskell.org/package/base-4.12.0.0/docs/Data-Functor-Contravariant.html#t:Contravariant
Как вы в хаскелях делаете это?
Я прочитал намного, в нем даже тацпклассов нет. Но вообще, планирую попробовать https://reasonml.github.io/ - ocaml с реактом и поддержкоц от facebook.
Почему она не фейлится на:
3:2:1:[] а даёт нам [3,2,1]
я так понимаю для двух скалярных сущностей она не определена:
3:2 должно фейлится
Какого хрена она тогда вместо этого начинает выполняться справа на лево?
В качестве аргументов принимает String String.
Есть функция которая возвращает Doc.
Какой наиболее простой способ конвертировать Doc->String или напрямую записать Doc в файл?
1. Нет зависимых типов (функции из значения в тип и зависимые пары) - погугли лямбда-куб, нет линейных/аффинных/uniqueness типов, нет сабтайпинга (ну это так-то только плюс, конечно), нет разделения между данными и коданными, нет системы эффектов, нет тотальности (всё залифчено - жди undefined)
2. Для хаскеля - нет. Если только как приятное дополнение
Есть конструкция вида:
do
операция1
операция2
...
операцияN
Каждая из операция с большой долей вероятности генерирует исключение. Как обернуть их в нечто вроде try ... catch, каждую по отдельности?
Был уверен что плюс функционального в том, что он проще для человека, что на нем проще изъясняться. По факту же что на нем реально можно делать? Работы нет, реальные задачи решаются проще большим другим количество инструментов.
Информатичка в школе говорила что такая хуйня нужна чтобы "мозг на место поставить". По факту (вернее с моей (низкой) колокольни) не видно задач и смысла в изучении такой хуйни. Продакшен ебал чисто функц. языки
>Никак не могу закончить курс на Степике. Значит ли это что я даун?
Курс от профессора отсебяткина из (постсовковой шараги ака мгу) ака Москвин что ли?
Не знаю, есть ли на степике какие-то доп материалы или задачи, но я смотрел первые 5 видео на ютубе и это было одно из самых бесполезных времяпрепровождений за чем-то околопрогромирования в моей жизни
>но ебаный хаскел абсолютно деревянный
Хаскель деревянный или ты? лол
Весь язык это интерфейс из монадотипов с тайпкласами и тулзов для работы с ними и io. "Учить" в общем-то и нечего
Всё остальное реализуется в абстракциях, запихнутых в эти узки рамки, и С/C++ биндах
Все либы легко читаются из сорсов
>Где блять взять интересные задачи, которые можно было бы решать на нем?
Там же, где и задачи для императивных языков
Продакшон веб мертв, но написать полноценный микросервис в <= 200 строк, который будет в разы быстрее и менее прожорливым относительно питухонов с нодами, вполне реально
Вообще ниша хаскеля сейчас в писании скриптохуйни и создание ебнутых мастермайнд динолоад систем по типу фейсбучной. Посередине огромная пропасть
>Для соревновательной проги не годен
Годен
>для алгоритмов чуть сложнее сортировки ебаной он уже не гибкий бля
Это скорее специфика всего фп
>единственный видимый плюс среднего вкатывальщика - хуй
Ну школьники-лицеисты 8+ классов осиливали, например
Хотя язык и вправду скорее для программистов, нежели вкатывальщиков
>Хотел назвать бесконечные структуры, которые в целом нахуй не нужны.
Это какая-то совсем частная хуйня. И в неё могут 99.9% фп языков, если что
>По факту же что на нем реально можно делать?
По факту что угодно
>Информатичка в школе говорила
>По факту (вернее с моей (низкой) колокольни)
>Продакшен ебал чисто функц. языки
)
> Курс от профессора отсебяткина из (постсовковой шараги ака мгу) ака Москвин что ли?
там и есть Москвин. Он же топ (или просто единственный) среди русского обуч. контента по haskel
> Хаскель деревянный или ты? лол
я конечно, лол
>>Для соревновательной проги не годен
>Годен
https://habr.com/ru/post/193722/
чувачок пишет, что разработка в принципе больше времени занимает, между такими же додиками будешь конкурировать?
Короче я успел написать и скопировать свой, разумеется, нахуй никому не нужный и абсолютно уёбищно банальный ответ на его ОП-пост и оставлю его здесь. Ведь извергаемое из недр добро надо где-то складывать, а не носить в себе.
>>1664023
Дизай языка конечно топовый и GHC выдаёт довольно шустрый бинарник, наверное, максимально оптимизированный из всех ФЯ, если не считать Окамл, и то идиоматичный код на окамле зачастую оказывается медленнее.
Проблема скорее не в языке и не в рантайме с компилятором, а в совершенно недоразвитой инфраструктуре, тулинге и прочих удобствах разработки, вернее их отсутствии. Второе, это отсутствие нормального онбординга для миграции разработчиков с других стеков, что в комбинации с необычным для большинства синтаксисом, и общей репутацией языка как академического, оставляет язык там, где он есть: застрявшим на уровне форсов конца нулевых.
С точки зрения менеджмента переход на хаскель весьма сомнительная затея: ООП-макакам нужно полностью переучиваться и отказываться от всего готового, то есть проебать уйму времени ради туманного повышения качества кода, которое даст какие-то выражаемые в деньгах преимущества может быть когда нибудь.
Ну и дополнительный недостаток: отлаживать и оптимизировать боттлнеки в хаскеле довольно муторно. То ли это от ленивости по умолчанию, то ли ещё из-за чего, но на том же окамле такие задачи решаются проще.
Нет, дело вовсе не в инфраструктуре. У перла вот инфраструктура была достаточно развитой, и где он? Да что там перл, руби с шарпом вон загибаются.
На популярность языка сильно влияет пиар. Пиарить заведомо переусложнённый язык ни одна корпорация не станет, это тупо невыгодно. Есть десятки новых языков, дизайн которых вполне конкурентоспособен, и если бы их пиарили, они бы давно взлетели.
А рядовые кодеры-профессионалы не станут тратить всё своё время на изучение языка, на котором они не смогут потом найти работу. Разве что for fun.
Я думаю «загибание» руби и тем более шарпа, - это фантазии.
Как человек работавший на перле, скажу что с инфраструктурой у него как раз всё было хуёво, но главная проблема была в том, что это write-only язык, годящийся скорее для всяких трюков и написания админских скриптов, чем для поддерживаемого кода.
Второе, это то что хаскель вовсе не сложен. В нём как раз всё просто и понятно, особенно если мозги ещё не забиты всякой gof-хуйнёй. Ну то есть есть конечно всякие экзотические специализированные вещи, но их знать вовсе не обязательно, хоть и может быть полезно для редких случаев.
Олсо, расскажи что это за новые конкурентоспособные языки про которые ты говоришь? Мне что-то только раст в с елмом в голову приходят.
Двачую, примерно такую же простыню написал в том треде.
Только вот это
>Второе, это отсутствие нормального онбординга для миграции разработчиков с других стеков
Это,на самом деле, первое. Хаскель предлагает разрабам освоить эзотерическую модель вычислений, которая, во-первых, вообще не похожа на привычное всем императивное программирование, которому везде учат, а во-вторых (на самом деле, как следствие) весьма нетривиально мапится на модель вычислений процессоров, то есть, на то, что "реально делает компьютер". В итоге, если ты не посвятил изучению этой эзотерики время, которого у тебя нет, то ты вообще не понимаешь, во что компилируются твои программы, даже на концептуальном уровне. В итоге имеем невозможность написания эффективного кода и оптимизации узких мест.
Плюс, как вкатывающийся добавлю: как-то совершенно экспоненциально растущая сложность происходящего, при перекате от совсем учебных вычислений факториалов и перекладывания списков из файла в файл к тем же по сути учебным примерам, но уже с логами, производительностью и сложными структурами данных.
Тут же начинают вылезать монадтрансформеры и сигнатуры с трудом влезающие в 80 символов, стопятсот расширений языка, которые сцуко расширяют (а по сути ломают, делая непонятным) синтаксис, который только выучил, произвольным образом, трюки с рекордами, линзы и прочие нихуя не элегантные способы записи того, что в сранном паскале бы записывалось в одну строчку и прочие IORef.
На этом месте, выигрыш от "чистоты и функциональности" начинает казаться не столь очевидным, а синтаксис ну вот нихуя не таким элегантным, как в учебных примерах.
Монадтрансформеры и линзы были попыткой сделать женерик паттерн для долгосрочной поддержки %что-то нейм% а-ля абстрактный солид в мире фп
Аддоны без проблем используются в проектах на десятки тысяч строк, ничего не ломают
Мутабельные стейты и прочие IORef мне приходилось затрагивать только в тцп серверах и гуях, больше они на хуй нигде не нужны
Писать без всего вышеперечисленного можно и никто не принуждает
Что ты подразумеваешь под эзотерикой - не понимаю
Хаскель настолько хорошо оптимизируется благодаря сильным фп концептам, которые в относительно современных языках сначала были нинужны, но сейчас со скрипом неосиляторства пердолятся еле осиливая схлопывания хвостовой рекурсии в луп
мимокрокодил
Тут всё отлично читается из типов, лол
Во первых, это хаскелевское решето эратосфена не решето эратосфена. Суть оригинального алгоритма в том, что ты проходишь сначала по каждому второму элементу, потом по каждому третьему и так далее до sqrt(n). В хаскелевском варианте же ты каждую итерацию проходишь по всем числам и убираешь те, что делятся на 2,3...sqrt(n). В результате, в хаскеле сложность O(sqrt(n)*n), а в оригинальном алгоритме O(n/2+n/3+...n/sqrt(n)).
Во вторых, самая заметная фича хаскеля - функции первого порядка для работы с коллекциями, давно есть в многих других языках, даже в джаве.
> В хаскелевском варианте же ты каждую итерацию проходишь по всем числам
А вот нихуя, значения мемоизируются, ленивость рулит.
>>1667203
> два супер сахарных лист конструктора
Перепишу на do-нотацию, будет на пару строчек длиннее, всё ещё лучше чем код слева.
>>1667512
> А потом ты пробуешь добавить в этот алгоритм логирование происходящего и рыдаешь
Добавляю Writer монад и хули ты мне сделаешь?
Стоит признать, что хоть что-то полезное написано на Haskell
>A smarter Dockerfile linter that helps you build best practice Docker images.
https://github.com/hadolint/hadolint
мимо-рубист
Обмажутся своими монадами и дрочат.
>Дампишь всё от stg до asm, пытаешься разобраться, почему вся куча засрана санками, начинаешь написание своей либы с GHC.Prim но это не байтоёбство, это другое.
>Обмазываешься тайпклассами в перемешку с singletons и th, {-# LANGUAGE CPP #-} в каждом втором модуле, но не, это не темплейты вообще ни разу.
Haskell: типобезопасность, чистота, программирование на тайплевеле, ленивость, каррирование по умолчанию, выразительная система типов и конструкции языка, высокая производительность по сравнению с остальными ФЯ.
Эрланг: фунциональный бейсик с процессами.
Схема: игрушечное скобочное петушение для обучения студентов.
Хаскельские темплейты заебись кстати, но почти нигде не нужны. В популярных либах почти не используются.
>>1687146
Ты занимаешься какой-то хуйнёй. Просто используй Haskell.
>>1687156
Это всё ещё лучше, чем долбоёбы, взявшие хаскель, но так и оставшиеся императивными дегенератами. Только от таких слышу про стеки монад-трансформеров и так далее.
Чистотой и строгой типизацией. И нет, он этим не лучше, у него это просто есть и сделано охуенно. Но если тебе это не нужно, понятное дело, он ничем не лучше.
>>1687394
>Хаскельские темплейты заебись кстати
Мальчик, ты пизданулся, TH меняется почти в каждой версии компилятора, заебёшься поддерживать. Уж лучше генерики (хотя они тоже крайне перегружены и мозголомны, хорошо, что добрые люди запилили generics-sop, этим уже можно пользоваться)
>Ты занимаешься какой-то хуйнёй.
Этой хуйнёй занимаются почти все авторы либ на Хаскелле, которые претендуют на продакшн. И поверь мне, даже если ты не видишь там откровенного байтоёбства, там будет: "Ехал инлайн через специалайз, видит инлайн в специалайзе реврайт-рул, сунул инлайн в реврайт-рул контроль фазы, STG-to-STG, STG-to-STG и снова контроль фазы." И всё это, кста, подбирается ручками путём долгих игр с бенчами и профайлерами хотя они там, самые лучшие по моим субъективным ощущениям, мне часто пиздят про тулинг, но всякие там бенчи и профайлеры в Хаскеле - заебись. Тесты тоже очень даже. И довольно ломучее - очень похожий код может либо в простейший цикл на асме развернуться, либо в ёбаное говно, которое будет насиловать мусоросборник.
В защиту Хацкеля могу сказать только то, что из него действительно можно выжать впечатляющую производительность, при этом показывая на уровне интерфейса либы только очень высокие абстракции. Такое в принципе невозможно на уровне недофункциональных суржиков вроде Скалы. Но чтобы это сделать, надо изрядно поебаться. Если хочешь написать очень красивую либу, бери Хаскель. Если надо тупо что-то закодить под конкретную задачу, попрыгай жопой на клавиатуре на С, или поебись с мудаёбской но огромной дажва-кодобазой, будет не так красиво, но быстрее.
>В защиту Хацкеля могу сказать только то, что из него действительно можно выжать впечатляющую производительность, при этом показывая на уровне интерфейса либы только очень высокие абстракции.
Ну какой нибудь tensorflow тоже, не то чтобы сильно замедляется питоновым интерфейсом с максимально хайлевелными конструкциями. Просто потому что снизу крутятся плюсы. Это, прямо скажем, хуёвый аргумент.
Знаю компанию которая использует в вебе хаскел на бекенде.
В чем его преимущество перед джавой или пхп для бекенда?
Гринтреды и супервысокоуровневые либы, сервис на которых можно написать в <200 строк. Правда, это есть практически во всех мейнстрим ФП языках
Хаскель мог бы быть бай дизайн быстрее практически всех мейнстрим ФП языков, но всё давно скатилось в тонны неведомого непрофилируемого спагетти
Хаскельная типизация проёбывает "иммуность к легасиванью" кода и начинает стрелять в ноги при малейшем изменении основ библиотеки
Хаскельная ленивость на хуй не нужна и в реальном мире выстрел в ногу по умолчанию
Хаскель - обычная абстрактная цпп биндилка с гц, только перечень фишек достаточно своебразный и, как показала практика, всратый
Хаскель мёртв для серьезного веба, автор самого популярного шеб фреймворка давно перекатывается на раст
>Хаскелл норм как первый язык программирования?
Как первый функциональный язык программирования норм, наилучший выбор. Но никогда не встречал того, для кого ФЯП был первым. хотя только что нагуглил и нашел это https://mmhaskell.com/blog/2018/6/4/bxit5i954uafn0n4gah3yrzcxnc3q6 Можешь стать первопроходцем, напиши потом через пол года результаты.
Теоретически, хаскель научит избегать тебя многих джуновских ошибок, но с другой стороны, вдруг тебе будет сложно перестроиться с фп на императивщину?
> Хочу настраивать Xmonad
DT насмотрелся? Для базовой настройки хаскель знать не нужно, достаточно читать документацию и копипастить код с инета.
>никогда не встречал того, для кого ФЯП был первым
SICP-вкатывальщики же, нет?
>Можешь стать первопроходцем
Заманчивая идея, тогда стану.
>DT насмотрелся?
Нет, у него скучные ролики по 10 минут, мне такое не нравится, да и если бы мне было настолько важно мнение кого-то в интернете я бы пересел на dwm, насмотревшись Люка Смита.
почему мне логотип эту хуйню напоминает?
Вот есть в прелюде функция words, которая получает строку и возвращает список из слов, разделенных пробелами.
https://pastebin.com/FYnEnx1r
И я совсем не понимаю, почему эта ебанина работает.
Откуда тут s' и нахуя? Нигде не объявляется, но почему-то работает.
Если удалить ' и оставить просто s, то функция будет работать так же.
Вот допустим передается строка, начинающаяся с пробела " a", s = " a".
dropWhile Char.isSpace s в кейсе отбрасывает пробел и получается
case "a" of
"a" сравнивается с пустой строкой, ничего не происходит. "a" сравнивается с s' которая, вроде бы, не отличается от s и почему-то условие выполняется. Если считать, что s и s' одно и то же, то получается s = " a" = "a" и бред какой-то ебаный s не s помогите нихуя не понимаю.
Далее через break вычисляются w и s'', которые должны быть равны "" и " a" соответственно, внутри вызывается words s'' и получается бесконечная рекурсия.
Так как функция все-таки работает, получается, что хуй знает откуда взявшаяся s' которую можно безболезненно поменять в коде на s каким-то образом принимает значение строки с уже отброшенным пробелом. words1, где я дописал строчку с объявлением s' работает так же. То есть, как я понял, это где-то как-то неявно почему-то происходит.
И это все равно не объясняет, почему функция работает, если s' в коде заменить на s. Ведь функции не меняют значения, и s как было " a", так и осталось.
Надеюсь, что кто-нибудь сможет разобрать мою шизофрению.
Почему сделали классы, а не множества, например?
2. Можно ли написать на хаскеле менеджер памяти, для какого нибудь интерпретатора?
1. https://stackoverflow.com/questions/32563737/can-two-different-typeclasses-have-the-same-method-names
Думаю, ты про это.
2. Скорее всего из классов из теории категорий.
> Если хочешь программировать на слегка посахаренном лямбда-исчислении - будь добр изжить императивное мышление.
> Если хочешь говорить по-китайски, будь добр изжить мышление на русском.
> Если хочешь ездить на скейте, будь добр изжить бипедальное перемещение.
Ты совсем сектант-долбоёб, или просто туповат и не можешь в разные навыки?
Подскажите как написать вычисление фибоначи в лямбде в 1 строку. Что-то вроде такого \ = let fib :: Num -> Num in ...
Все по банальному сценарию: залетную императивную маню обоссали, и она, утирая слезки, дрожащим голосом вскукарекивает "А вот мы и скатились до уровня ФП.". Маня, мы проходили это сотни раз: ты еще некоторое будешь кукарекать и зашивать свой пукан, омываемый тугими струями элитной мочи и захлебываясь ею. При этом конечно же будешь думать, что всех искрометно затролел, отвечая бранью, и даже когда тебе укажут на этот факт, то вспомнишь свой статус вконтакте "никогда не здавайся)))" и продолжишь по инерции сглатывать уринку. Так что окропляю твой ротешник и рекомендую свалить отсюда.
>>1765930
Всё ведь просто, тебя никто не трогал, ты сам пришёл и начал вонять "а вот в хаскили нельзя как в моей мутабельной дрисне". После того как тебе ответили как это делается и без деструктивных апдейтов, ты начал недовольно кукарекать.
Ты же нихуя не понимаешь что за линзы, призмы, какие Lens вообще решает задачи, до решения которых твоей мейнстримовой параше ещё лет 20 в говне плыть и плыть, но при этом кукарекаешь что в хаскеле чего-то там нет, не указывая при этом чего.
https://pl.kotl.in/XE-IzGVCv
Так стронг тайпинг фп никогда - нигде не использовавшееся говно без задач, toy language статус хаскеля после стольки лет пердолинга - лишнее тому подтверждение
Какое-нибудь ужасное идиоматическое кручение нила в лиспе на практике покрывает гору хаскельных велосипедов и свистоперделок к ним
>начал сомневаться в скорости хаскелля
Хаскельный перформанс - неведомая непрофилируемая хуйня
Весь теоретический потенциал агрессивных оптимизаций на практике срёт в штаны, особенно из-за войны с ленивостью
ФБ для своего спам фильтра пришлось фиксить и допиливать компилятор, например
Шеб за пределами чат ботов и хелоу ворлд рест эндпоинтов просто мёртв, хоть и выглядит как красивый дсл в 50 строк
> Как же блядь заебали type mistake. Нет, КАК ЖЕ ОНИ БЛЯДЬ ЗАЕБАЛИ.
Ну да, лучше ебаться с теми же ошибками, но в рантайме. А потом еще сотню юнит тестов писать, потому что ТИПЫ ЕТО ПЛОХА, СКОМПИЛИРОВАТЬ МОЙ ХУЕВЫЙ КОД НЕ ДАЮТ
> Быстрая вещь 200Мб весить не будет.
А что в хаскеле 200мб весит? Да, у него статическая линковка, но даже йобы с тонной зависимостей типа пандока весят мегабайт 100, а твой хелловорлд и десятка весить не будет.
Во-первых есть линзы, во-вторых, глубокое заглядывание в структуры - это code smells в любом языке, в-третьих если ты после Сишарпа или на чем ты там кодишь напишешь на какой-нибудь Джаве frame.getLocation().x = newValue, то ты тоже будешь плакать. Линзы по крайней мере обладают вполне определённым поведением, а не зависят от реализации геттеров/сеттеров, которые можно написать разными способами, при этом все способы будут немного неправильные, просто неправильные по-своему.
>>1765918
Возможность написать линзы средствами самого языка наоборот свидетельство гибкости и выразительности языка. На языках уровня Джавы линзы написать просто невозможно. На Скале более-менее рабочие линзы можно получить только обмазавшись макросами с ног до головы. На Хсакеле при желании линзу можно сделать вообще не подключая библиотеку с линзами, потому что линза это тупо функция вида forall f. Functor f => (a -> f b) -> s -> f t.
>>1765922
Мне кажется ты ничего не знаешь про Хаскель, потому что в нём как раз гораздо больше всего, чем во среднестатистическом языке. Поэтому и порог вхождения выше. А про факториалы - это фольклор среди публики, которая как раз дальше факториалов язык не освоила.
>>1765943
Самое забавное, что трейдоффы - это вовсе не отсутствие деструктивных апдейтов а теперь набери воздуха: они там есть, а самый простой способ определить мамкиного троля, который ничего не знает про язык, это как раз доёбывание до воображаемых проблем и неспособность указать на реальные.
>>1774809
Тебе в Питон. Там даже пропущенная запятая при перечислении элементов массива ошибкой не является. Зато какая хуйня на выходе получается, любо-дорого смотреть.
>>1774903
>особенно из-за войны с ленивостью
Опять мимо кассы. Мамкины тролли не знают, что ленивость уже лет 10 не является основным источником проблем производительности. Впрочем лисперы застряли годах в 80-х, тогда Хаскеля вообще не было, меня удивляет сам факт, что скобкоёбы откуда-то знают про его существование.
В хаскеле довольно сложная система типов, по сравнению с хаскелем какая-нибудь схемка кажется детской игрушкой.
Чистота на самом деле круто, но только если ты осознаёшь что рантайм по сути вызывает большую чистую функцию, чтобы понять что ему насайдэффектить дальше. В результате получается тотальная тестируемость и предсказуемость всего твоего кода.
А вот паттерны пожалуй соглашусь, сыроваты. Не разжевали ещё достаточно хаскель на книги с бест практиками.
> Тебе в Питон. Там даже пропущенная запятая
Хоть и квадрипл, но попахивает пиздежом.
Мне кажется проще вообще всю эту хуйню заново переставить...
Его модер снёс как ты меня вычислил, засранец? На счет тулинга не согласен. В Хаскеле охуенный тулинг. На Скале попиши, чтобы понять, что такое хуёвый тулинг. И даже не пробуй использовать Criterion, QuickCheck, HUnit, weigh, не используй Stack и даже GHCi не вздумай запускать. Не дай Б-г привыкнешь, потом будешь кровавыми слезами плакать от скалийных эрзацев. Ну если совсем хочешь побыть "нижним" в IT-BDSM-играх, примени к Скале java-тулинг. Например, мавеном проекты пособирай или jmh поюзай для Скалки.
На счет оптимизации - согласен. Проблема хаскелевского перформанса в непредсказуемости. На eager-функциональных говнах программа тормозит всегда (и не знаю, что за перформанс ты нашел в ОКамле, может ты его просто лучше знаешь и обходишь ловушки, как те деятели на Питоне, которые удивлены "медленным" IO в Хаскеле, когда вызывают getLine в Хаскеле и, о чудо, Питон оказывается быстрее). Но добавление пары строк в eager-мешанину перформанс почти никогда фундаментально не роняет, а в Хаскеле регрессию можно словить внезапно. Для бизнеса это хуёво. Лучше, когда у тебя 10 серверов, но ты знаешь, что это точно будет работать, типа привык уже и всё рассчитал, чем когда у тебя один сервер, но внезапно наебнулась какая-то оптимизация и код стал работать в 8 раз медленнее все равно быстрее, чем на eager, но ты же не ожидал такой подставы, у тебя даже планах не заложена покупка дополнительного железа на какой-то минорный апдейт
Оптимизация Хаскеля - это как-то, блядь, вот так: https://stackoverflow.com/questions/45334985/when-to-use-cps-vs-codensity-vs-reflection-without-remorse-in-haskell Попробуй 3 способа, может быть один из них окажется в 8 раз быстрее остальных, а может быть все 3 - одинаковые. Это реально заябывает, я не хочу писать 3 варианта своей библиотеки чисто ради того, чтобы проверить, какая из них быстрее. Иногда да, хочется тупо на сишке писать, а не копаться в ассемблерных дампах и разбираться почему у компилятора крышу снесло при чисто декоративных изменениях.
>>1664138
Согласен. Вот тут чувак на 10:25 эту тему пиздит https://www.youtube.com/watch?v=QyJZzq0v7Z4
>>1776767V
Хорошее сложнее сделать, чем плохое. Про реальные недостатки сможешь прочитать в рассылках, они там постоянно обсуждаются.
>>1776753
Я Лиспом не владею и ничего про него сказать не могу. Но отсутсвие пейперов как-бы намекает, что не всё так охуенно в Датском королевстве.
>>1776760
>В хаскеле довольно сложная система типов
Мне тут пиздели, что синтаксис обновленного Паскаля умещается на одну страницу. Интересно, тайпчекер Хаскеля уместится на одну страницу? Что-то подсказывает, что да, хотя я не проверял.
>>1776889
Я такую фичу автоматизировал и выводил в продакшн. Самое смешное, что она, сука, во-вторых, работала, а во-первых, была согласована с безопасниками и её ни в коем случае нельзя было менять.
Питоноёбы доставляют, как ни крути. Питон - это язык для ML-дегенератов. Хорошо, что ML нивелирует дегенератизм отдельных личностей. Ну как-бы есть долбоёбы от IT, но у них охуенная интуиция, они хорошо в предметных областях разбирабтся. Прогеры с математическим образованием их дополняют. В итоге у питоноёба - "захуячиь модельку, может сработает", а у хаскельёбов "сделать всё по топчику и по математике." Все профессии нужны, все профессии важны.
Смеялся.
Сейчас любой современный ЯП поддерживает ФП и чем новее, тем в большей степени. Наоборот, если ЯП не поддерживает ФП, это либо говно мамонта, либо просто убогое поделие вроде goвна.
А в old-java-style ООП как раз все разочаровались ещё когда ты пешком под стол ходил, и на ОО-языках сегодня стараются писать более менее плоско, и без всей этой gof хуйни, юзая по максимуму композицию и интерфейсы с дженериками, которые является урезанной версией хаскельских тайпкассов. Кто знает, может когда-то мариыханы доэволюционируют и до них а то что в свифте, что в ф-шарпе до сих пор функтор нельзя написать
От ФП языки взяли максимум лямбды, потому что это реально удобно в некоторых ситуациях. Но взять 1-2 фичи из ФП != победа ФП как концепции.
Это не в ООП разочаровались, а в отдельных ее принципах. Пример - наследование. Стараются его не использовать когда не надо, предпочитая композицию или аггрегацию. Во всем остальном - концепция разделения программы на классы и танцы вокруг объектов, основной посыл ООП, что тогда выстрелил, что сейчас активно используется везде, потому что эта концепция идеально ложится на человеческое сознание и ВНЕЗАПНО крупными проектами становится управлять куда проще. И расширять их тоже.
Даже в ядре Линукса, написанном на чистых сях где нет ООП, есть куча реализаций ООП конструкций через костыли.
Покажи мне хотя бы один крупный всемирно известный проект, который от А до Я написан в духе ФП и про который знает каждая собака? Покажи мне тонны вакансий на ФП языки. А, их нет? Потому что ФП языки используют 2 с половиной компании по всему миру. Концепция как таковая провалилась с треском и оказалась никому не нужная. Отдельные ЯПы позаимствовали некоторые фичи, типа лямбд, и все.
Я ещё правда и Липовача не дочитал, но решил задачки на кодварс порешать, и вот столкнулся с задачей нарциссичного числа.
Я его решил через функцию объявив:
narcissistic :: Int -> Bool
Но у меня не проходит последний тест, потому что изначально функция была задана как:
narcissistic :: Integral a => a -> Bool
Вот, и я не особо понимаю как с этим работать.
Ты же понимаешь, что хаскель - язык бай дезигн с абстрактной системой и ничем кроме нее, прмитивы отсутствуют как таковые?
Есть вооброжаемый фрейм интерпритации данных, вопрос один: нахуя его реализовывать программно?
Мне лень расписывать, тем более когда финт ушами и переворот мейнстримного "примитив + абстракции -> примитивы -> реал ворлд" в "абстракции + черный ящик -> реал ворлд" на практике пёрнул в лужу
Ничто не мешает писать согласно категори теори на любом из языков и без куколдного велосипеда
>Лол, да что там автоматизировать.
Под "автоматизацией" я имел ввиду следующую задачу: есть портянка говнокода на Питоне с ML-моделью, которая запускается ручками в ждупутере, тормозит, падает и работает на 100 тестовых клиентах. Нужно сделать так, чтобы эта модель работала на всём секторе клиентов малого и микробизнеса, и каждое утро ровно в 10 часов выкладывала красивые отчеты на столы региональным менеджерам. Очевидный вариант: переписать на Скалке, использовать Спарк, прикрутить к Спарку Hyperscan вместо питоновских регулярок. Но хуй там плавал. Мало того, что сам алгоритм вычисления фичей написан датасаентистом, чей разум был помутнён влиянием Слаанеш, так еще там куча пиноёбских багов, которые с точки зрения интерпретатора - вовсе не баги. И самое смешное то, что модель обучена именно на этом сете ебанутых фичей. Ну модели ведь похуй, что ей подают на вход. Если ты будешь подавать на вход прибыль со знаком "-", она просто научится тому, что отрицательная прибыль - это хорошо. В итоге задача автоматизации сводится к тому, что надо воспроизводить ебанутейшую питовскую программу на чём-нибудь более производительном. Или искать другие варианты.
>Дегенератов надо просто не нанимать.
Разделения на дегенератов и не дегенератов не существует. Пример из жизни. Моя первая работа, сеть бутиков модной одежды. Я там работал программистом. Была там одна тёлочка, которая кое-кого из начальства подзаебала и коммерческий директор мне сказал: "ну ты типа научи её как делать отчеты в Access, если за неделю она не научится, значит она тупая, я её под этим предлогом уволю". Я не очень хотел играть роль инструмента, который сделает грязную работу. Вообще, бесят грязные пидарасы в чистых рубашках, которые говорят что-то вроде: "Мы не хотим брать этого человека, завали его на собеседовании". В Игре Престолов было хорошо сказано, что если ты вынес человеку смертный приговор, то приведи его в исполнение сам, иначе ты трус и хуесос. Но знаешь, обучить её Access - это была миссия невыполнима, она вообще нихуя не секла, полное отсутсвие логического мышления. Но при этом она была одной из тех немногих людей, которые посмотрев на выставку моды в Италии могли сказать, что вот это шмотьё будут покупать и носить в Екатеринбурге, а вот это - не будут.
Я уж не помню, уволили её или нет. Но суть не в этом. Есть люди, которые умеют классно решать какие-то одни задачи, но могут показаться полными "дегенератами" в других. Так и с data science. Крутой датасаентист может быть очень хуёвым программистом часто так оно и есть, а очень хороший программист не факт что что-то сможет в DS. Суть в том, что надо учиться и искать инструменты, которые позволяют людям с различными талантами эффективно взаимодействовать, а не списывать всё на то, что кто-то якобы "дегенерат". Ну только если человек реально не дегерат.
По моему мнению, если программист родившийся и выросший в России, не любит Хаскель, не понимает его красоты, его системы типов, ссылочной прозрачности, бескрайних возможностей multi-stage programming, ночных хакатонов, осеннего релиза, первой версии синглтонов, июльских багрепортов, FFI-просторов, функционального подхода, функционального характера - он дегенерат. Ведь ты же русский программист? Ты родился в России? Ты ходил в среднюю школу? Ты служил в армии? Ты учился в техникуме? Ты работал на заводе? Ты программировал на Delphi? Программировал на Delphi? На Delphi программировал? Программировал, а? Ты на Delphi программировал, а? Программировал? Чего молчишь? На Delphi программировал? А? Чего косишь? А? Заело, да? Программировал на Delphi? Ты, джаваёб? На Delphi программировал? Программировал, падло? Программировал, гад? Программировал, падло? Программировал, бля? Программировал, бля? Программировал, бля? Чего заныл? Программировал, сука? Программировал, бля? Программировал, бля? Программировал, бля? Чего ноешь? Чего сопишь, падло? Чего, а? Заныл? Заныл, падло? Чего сопишь? Так, бля? Так, бля? Так вот? Вот? Вот? Вот? Вот, бля? Вот так? Вот так? Вот так? Вот так, бля? На, бля? На, бля? На, бля? Вот? Вот? Вот? Вот? На, бля? На, сука? На, бля? На, сука? На, бля? На, сука? Заныл, бля? Заело, бля?
Нет, ну в 2010 таким как-то можно было бы еще более-менее жирно троллить, но сейчас уже вообще никак.
>>1778662
>прмитивы отсутствуют как таковые?
Ну да, GHC.Prim отсутсвует как таковой.
>Ничто не мешает писать согласно категори теори на любом из языков и без куколдного велосипеда
Ну да, на scala cats попиши и расскажи, где велосипеды.
Докажите обратное.
Ну нет. Дегенерат это человек претендующий на определённую компетенцию, то есть сам заявляет что он синиор хуйня девелопер, но выполнить ничего не может. Тёлочка, про которую ты рассказал, это как микроскоп, которым забивали гвозди, это проёб управления.
Я вообще не увидел никакой проблемы с питоном, кроме опять же проблемы управления. Никто не надоумил начальство, что датасатанисты хуёвые программисты, и надо нанять тех кто допишет, оптимизирует и превратит в нормальный сервис тот нашлёп что сатанист сделал у себя пайнотебуке. Причём здесь уже реально неважно, питон это будет или скала, или что-то ещё.
> не любит Хаскель, не понимает его красоты, его системы типов, ссылочной прозрачности
Всё больше убеждаюсь что функциональное программирование это болезнь по типу аудиофилии. Если человек слаб мозгом и влез в ФП, считай что общество его потеряло, он будет как Голум ходить и шипеть про свою прелесть, постоянно причитать что у вас мол нет ссылочной прозрачности или чистоты, тут не гибко, тут не гомоиконно, тут система типов не такая как надо, упорно закрывая глаза на минусы ФП, которых не так уж мало. И это при всём при том что язык это как ебаная отвёртка, чтобы собирать большие и полезные вещи. Да, у функциональщиков отвёртка красивая, умеет менять размер и профиль, но это же всего лишь сука отвёртка, и чтобы сделать что-то полезное нужны ещё пила, топор, уровень, лопата (читай библиотеки, фреймворки, базы данных, люди в конце концов). И каким-то чудом почти все работающие пилы, топоры и лопаты сконцентрированы в других языках. Может быть потому что чуть меньше уделяли внимания отвёртке?
Давай я тебе попроще скажу, чтобы ты не цитировал и не опровергал каждое моё слово. Хаскель сосёт когда нужно сделать симуляцию в довольно большом стейте, к примеру сделать игру жизнь с полем 10к х 10к. Здесь чистота играет против него, и никакая умная распорка (что там у вас, STMonad сейчас для такого?) не оправдает использование хаскеля для такой задачи. Ну не будет никакого бонуса ни от ссылочной прозрачности, ни от системы типов и прочего.
> Так, бля? Так, бля? Так вот? Вот? Вот? Вот? Вот, бля? Вот так? Вот так? Вот так? Вот так, бля? На, бля? На, бля? На, бля? Вот? Вот? Вот? Вот? На, бля? На, сука? На, бля? На, сука? На, бля? На, сука? Заныл, бля? Заело, бля?
Хуя ты сломался.
> Тьюринг-полнота присутствует
Толку от этой Тьюринг-полноты, если ввод-вывод не возможен в чистом ФП.
В Хаскелле(да и в чистом ФП впринципе) не возможно передать некоторые концепции, которые хаскеллисты просто перекидывают на компилятор, потому их язык не способен в описание этих концепций.
Алсо, ФП не полон, потому что не может адекватно описывать некоторый мир/вселенную.
Банальный пример:
Есть объект Наташа Еотова типа Человек:
Human("Наташа", "Еотова")
Но вот так случилось, что она женилась на Ване Ерохине и сменила фамилию на Ерохина.
Вопрос: как описать этот процесс в терминах ФП?
Ответ: склонировать Наташу Еотову с новой фамилией, а старую выкинуть в мусоросжигатель.
Звучит глупо и не естественно, не так ли?
Даже математику Хаскелл не поддерживает в полной мере(только её часть), ведь в математике огромную роль играют ограничения.
Аналогия показывает концептуальную нестоятельность и непрагматичность Хаскелла как язык общего назначения. Или напиши хотя бы 2D игру с нуля.
Просто признайте, что Haskell - DSL для части математики, называемой лямбда-исчислением, в той же степени, что и JS это DSL для написания web-приложений.
1) лямбда-синтаксис. Ок, приятный сахар, но не более. Семантически без разницы, передашь ты анонимную функцию, или объявишь строчкой выше.
2) чистые функции. Никто не запрещает писать их хоть на Си. Да, конечно можно поговорить о _больших_ гарантиях чистоты (потому даже хаскель не гарантирует от unsafe под капотом), но это всё ещё вопрос кодстайла, бестпрактик и трейдоффов.
3) иммутабельность, см. про чистые функции.
4) ADT. Ребята, ADT -- это про типы данных, точка. Не про ФП, ООП, а сугубо про данные. Может быть процедурный бейсик с АДТ, и тру-ФП язык без них. хаскель-детям, не видевшим другого ФП, не понять.
А теперь, сектанты -- вам слово: нахуя индустрии ваши ритуальные приседания и игрушечные языки без библиотек? В каких областях применения они доминируют и дают больший перфоманс?
Отсутствие наллов, монадки. Посмотри на раст - в нем что для Option, что для Either есть монадо-подобный сахарок.
>А теперь, сектанты -- вам слово: нахуя индустрии ваши ритуальные приседания и игрушечные языки без библиотек? В каких областях применения они доминируют и дают больший перфоманс?
Почему что-то должно доминировать и давать ПЕРФОМАНС? На хаскеле просто приятно писать, вот и все. Я так само выбрал шарп, который обьективно был хуже джавынет тонны библиотек, под мобилки не напишешь, тогда даже кроссплатформы не было, но имел тонну приятного сахарка и фиксы джавовских ошибок.
>>1783945
Ты навел пример карты 10к на 10к. Пихаешь ее в ST монаду, заворачиваешь ее в Embed эффект и вот ты уже по сигнатуре любой функции знаешь, изменяет она ли эту карту, пишет ли она лог, делает ли запрос на сервер и тд. Хаскель это не про иммутабельность, хаскель это про явное различие чистых и "нечистых" функций на уровне типов. Он прекрасно подходит для написания dslв том числе, или даже в первую очередь, императивных dsl, во многом благодаря сахарку для монад.
Или ты думаешь, что на хаскеле все пишут чистые функции типа String -> State -> String? Я тоже так думал, но как только начал писать на нем код, разорвав себе анус, понял, что никто так и не пишет - все юзают или mtl, или системы эффектов.
Алсо, вот тебе ИМПЕРАТИВНАЯ ecs на хаскеле, как пример императивной dsl: https://hackage.haskell.org/package/apecs
Отлично подойдет к примеру с игровой картой, кстати.
Отсутствие наллов -- это не имеет отношения к ФП. В паскале их нет, как и бейсик, такие-то ФП языки. Не разумно и странно всё, что есть в Хаскеле, но не в Си, называть ФП.
На раст посмотрел -- лютая низкоуровневая императившина, с контролем времени вполне себе мутабельных состояний.
Давайте не будет во всём видеть монады, а увидев монаду -- кричать что это ФП. А Option и Either, как и прочие алгебраические типы -- это, простите за тавтологию, часть системы типов -- штуки ортогональной к ФП/ООП/Процедурному.
С точки зрения приятно писать -- респект, нормальный аргумент. Плюс польза для развития мозга и кругозора. Если бы ещё тот же Хаскелль с завидной регулярностью не продвигался неофитами как супер-пупер штука, которая заменит сейчас жабу, дваскрипт, питон и С++ разом, просто опытные дяди, пишущие промышленный код, ещё не знают. Правда том, что большинство этих дядь потрогали и ФП, и какой-нибудь хаскель, кложу, как и раст, и ничего нового неофит не приносит, а сугубо создаёт шум.
1 - функции высшего порядка это основное
2 - на си их нельзя писать из-за невозможности вернуть буфер. Именно фпшники придумали ту машинерию, которая позволяет нормально использовать чистые функции
3 - аналогично
4 - тем не менее, именно замороченность на фп заставила людей задавать правильные вопросы, чтобы получить на них ответы
1) Ну если функции высшего порядка -- это основное, то Го -- ФП, лол.
2) В те времена, когда появилась "машинерия которая позволяет нормально использовать чистые функции" инженеры не выделяли в своей среде "ФПшников", а дядюшка Боб бегал в коротких штанишках и изучал Алгол-68. (кстати, зацени примеры кода в Wiki)
4) ох-ох, вот опять ФП -- луч просветления в тёмном царстве невежества. Вас послушать, так больше полувека индустрия развивается под чутким влияние ФП, но почему-то в основном поперёк ФП. Прям тайная ложа ФП-массонов,
А по факту люди умнее меня и тебя боролись со сложностью всё это время, в т.ч. и с помощью тех инженерных принципов, которые сейчас лежат в основе функционального подхода. И принципы эти а) не эксклюзивны для ФП, б) не серебряная пуля, в) _реализация_ этих принципов в тех или иных языках -- ещё более не серебряная пуля
https://www.microsoft.com/en-us/research/publication/outsideinx-modular-type-inference-with-local-assumptions/
IO - это как стейт монада, в которой стейтом является весь мир. Правда, получить экземляр мира за всю работу программы ты можешь только один раз, что и делается в функции Main
Значит, такие функции детерментрованы, ведь даже Random :: IO Int внутри можно представить как Random :: World -> (World, Int), а так как возможных состояний мира бесконечно много, то и результатов такой функции бесконечно много. только попробуй доебаться, что из-за некоторых квантовых эффектов вселенная недетерминирована, поэтому хаскель сасать
Ну и естественно, с такого описания IO монады, можно понять, что сайд эффектов в функциях нет, так как для таких функций любой эффект не сторонний.
>>1793025
Можно запустить новый тред.
main создаёт какой-то экземпляр IO, который потом каким-то образом запускается каким-то механизмом.
forkIO получает IO и запускает его.
Значит ли это, что forkIO получает новый экземпляр мира?
Какой экземпляр мира подаётся на вход IO, выданной функцией main и какой экземпляр мира подаётся на вход IO, переданной функции forkIO?
Наверное пример об IO как о монаде, стейтом которой является весь мир - это просто пример, метафора или даже что-то наподобии мнемонического правила. Как например newtype: мы можем представлять себе, что это какая-то обёртка, но компилятор заменяет их тем, что в них содержится и с точки зрения машины никаких обёрток нет. Но это не мешает нам представлять себе, что обёртка есть, ведь для того она и была придумана.
IO -- это как костыль Хаскелля, который ты не можешь написать сам на Хаскелле.
Ну и уж конечно ты получаешь экземляр _не_ один раз (ну или этот один экземпляр мутирует сам, независимо от кода ФП-программиста, лол), например когда несколько раз выводишь текущее время
>IO -- это как костыль Хаскелля, который ты не можешь написать сам на Хаскелле.
Ага, а class - это как костыль Java, который ты не можешь написать сам на Java.
>который ты не можешь написать сам на Хаскелле.
Вообще забавное утверждение, учитывая, что как и любой нормальный ЯП, хаскель написан на самом себе, а сишные куски присутствуют либо в рантайме, либо как часть компилятора ответственная за генерацию си кода, которую он поддерживает.
>который ты не можешь написать сам на Хаскелле.
Не так уж сложно:
module MyIO(MyIO, myPutChar, myGetChar, convert) where
type Input = String
type Remainder = String
typeOutput = String
dataMyIO a = MyIO (Input -> (a, Remainder, Output))
apply :: MyIO a -> Input -> (a, Remainder, Output)
apply (MyIO f) inp = f inp
myPutChar :: Char -> MyIO ()
myPutChar c = MyIO (\inp -> ((), inp, [c]))
myGetChar :: MyIO Char
myGetChar = MyIO (\(ch:rem) -> (ch, rem, ""))
---------------------------------------------------------------------------------------
instance Monad MyIO where
return x = MyIO (\inp -> (x, inp, ""))
m >>= k = MyIO (\inp ->
let(x, rem1, out1) = apply m inp in
let(y, rem2, out2) = apply (k x) rem1 in
(y, rem2, out1++out2)
---------------------------------------------------------------------------------------
convert :: MyIO () -> IO ()
convert m = interact (\inp ->let(x, rem, out) = apply m inpinout)
>Аналогия показывает концептуальную нестоятельность и непрагматичность Хаскелла как язык общего назначения.
Хаскель хорош именно как язык общего назначения.
Если нужно написать какое-нибудь байтоёбство вроде https://github.com/Cyan4973/xxHash то да, сишка лучше. Да, это можно почти дословно портировать на Хаскель и работать будет почти так же, но сишка - лучше. Если что, я выполнил частичный порт этой либы чисто для себя, я его не публиковал, мне хотелось, чтобы это работало на unpinned ByteArray#, поэтому не воспользовался FFI, сейчас думаю, нахуй мне unpinned, возможно, на обычных указателях было бы лучше и ничего портировать бы не пришлось, портирование кода - обезьянья работа, ощущение - пишешь на неудобном варианте сишки. Ни от каких проблем сишки, вроде выхода за пределы буффера если ты где-то неправильно вычислил индекс, Хаскель не спасает когда ты пишешь на нём как на сишке. Добавляет проблем - примитивные операторы более громоздкие, чем в сишке, плюс надо разбираться в монадках и том, как работает конпелятор, чтобы не обосраться с производительностью. Я еще Salsa20 портировал, те же проблемы, несколько дней ебался.
Если нужен какой-нибудь "DSL для части математики", а вернее язык, позволяющий не программистам что-нибудь наговнячить, то там Питон лучше, даже R - лучше. На Хаскелле всё это можно сделать, но нужно тупо лучше разбираться в программировании, вопрос - нахуя если есть инструмет, который позволяет решить аналогичную задачу с меньшим усилием? Тем более, что в случае Питона задача скорее всего уже решена.
Но именно как язык общего назначения Хаскель рулит. В нем можно сделать почти всё. Он и Питон может эмулировать и сишку. В каждой конкретной задаче он будет немного проигрывать специализированному инструменту по трудозатратам или скорости. Но если у тебя несколько задач, которые нужно объединить в одном приложении, то Хаскель как универсальный инструмент на порядок качественне, чем любые другие языки, которые претендуют на роль универсальных.
>>1784291
>Ответ: склонировать Наташу Еотову с новой фамилией, а старую выкинуть в мусоросжигатель.
>Звучит глупо и не естественно, не так ли?
Вот этим https://arxiv.org/pdf/1803.08617.pdf парням расскажи про глупость использования иммутабельных структур. Нет, не глупо, иногда даже очень полезно, зависит от задачи. И Хаскель, как язык общего назначения, не вынуждает использовать какую-то одну парадигму. Можно сделать и так и по-другому. Естественно, он немного проиграет специализированному языку, заточенному под конкретную парадигму, но именно как универсальный он хорош. Хотя сжигает жопу, когда хочется и производительность сишки и низкий порог вхождения Питона одновременно, это компромисс, присущий любому универсальному инструменту.
>Хаскель это не про иммутабельность, хаскель это про явное различие чистых и "нечистых" функций на уровне типов.
Кстати да. Много раз слышал от мамкиных троллей, что Хаскель не работает, потому что он "чистый". А вот люди, программирующе на Хаскеле, больше его описывают как язык, позволяющий обозначать эффекты. Т.е. Хаскель и есть именно императивный язык, в котом вся система типов крутится вокруг императивных эффектов.
Что есть в императивной Джаве для обозначения эффетов? Нихуя. С чего начинается работа с Хаскелем? С того, что надо понять, что такое монада. Так монада - она как раз про эффекты и императивное программирование.
>На раст посмотрел -- лютая низкоуровневая императившина
Неплохая, кстати. Но более тяжеловесная, чем Хаскель. Люди, мигрировашие с Хаскеля и других языков на Rust, утверждают, что Rust быстрее, но требует больших усилий в предварительном проектировании и сопровождении.
>Правда том, что большинство этих дядь потрогали и ФП, и какой-нибудь хаскель, кложу, как и раст, и ничего нового неофит не приносит, а сугубо создаёт шум.
Нет, в этом нет правды. Правда в том, что дядям нет смысла мигрировать на более эффективный язык потому что помимо эффективности самого языка есть множество других факторов, которые заставят тебя выбрать ту же джаву.
Ты дурачок, да?
Ты можешь написать монаду MyIO, или любую другую. Но т.к. это не "Magic IO" все твои монадические вычисления в MyIO не выведут даже пук на экран, пока ты не используешь IO под капотом.
>>1795860
Ты можешь написать MyST, и он будет не хуже. MyIO выше уже обосрались написать, только обернуть
>>1795865
Критикуют ФП -- скажи "ты просто не осилил" (С)то лучших практик защиты ФП
Две особенности IO:
1) Это тип, у которого нет инстансов. Можно использовать "IO a", но не инстансы. Т.е., как я понял, нет типов-инстансов IO.
2) Компилятор может инлайнить или по-другому манипулировать любым другим выражением в программе, но он ничего не будет делать с IO-экшном.
Безграмотная долбоёбушка, ты не можешь написать ни одного поста чтоб не обосраться.
Начнём с того, что твой тезис
>IO ты не можешь написать сам на Хаскелл
изначально ошибочен, так как IO написан на Хаскелле и его имплантацию ты можешь посмотреть на hackage.
Потому что IO - это никакое не волшебство, это обычная монада, которая пишется так же, как любая другая, и её значения это не какие-то магические функции передачи мира, а просто данные.
Во-вторых, в моём примере задаётся логика работы IO монады, без какой либо обёртки над оригинальным IO вообще.
Дальше можно сделать:
module MyEcho where
import Char
import MyIO
myPutStr :: String -> MyIO ()
myPutStr = foldr (>>) (return ()) . map myPutChar
myPutStrLn :: String -> MyIO ()
myPutStrLn s = myPutStr s >> myPutChar ’\n’
myGetLine :: MyIO String
myGetLine = myGetChar >>= \x ->
if x == ’\n’ then return []
else myGetLine >>= \xs -> return (x:xs)
myEcho :: MyIO ()
myEcho = myGetLine >>= \line ->
if line == ""then return ()
else myPutStrLn (map toUpper line) >> myEcho
main :: IO ()
main = convert myEcho
В чём суть твоей предъявы совершенно непонятно. Как будто у тебя претензии к тому, что встроенные getLine/putStr работаю со встроенной IO. Но дело в том, что никаких фундаментальных ограничений для написания своих getLine/putStr, которые бы работали с другим типом нет, просто никому нахуй не нужно переписывать кусок стандартной прелюдии для чтения/записи с/на девайс.
>куд-кудах нельзя написать IO монаду на хаскеле
>отправляют на hackage смотреть реализацию IO монады на хаскеле
>пук, сделаю вид что не обосрался
>за 3 минуты пишут свою IO монаду на хаскеле
>пок-пок это обрётка над "волшебной (sic!) IO"
>где она её оборачивает, в чём заключается отличие?
>пук, сделаю вид что не обосрался
>уже несколько анонов объясняют что IO это просто контейнерный тип, хранящий обычные данные, работающий по простой логике
>покпокпок короче это ты обосрался, а не я!
Какой же ты дебильный кусок, просто уёбывай. Самое смешное что ты написал 0 содержательных постов, сплошной пердёж в лужу с обосрамсом через слово.
Заранее говорю что я не траль и в хаскеле нуб
Я знаю как подобные IO штуки работают в скале, в точке входа висит интерпретатор который запускает твой IO
В хаскеле можно написать свой интерпретатор для своего IO? Обязательно ли использовать main :: IO () в качестве точки входа как тут:
>convert :: MyIO () -> IO ()
>convert m = interact (\inp ->let(x, rem, out) = apply m inpinout)
Ты всё равно приводишь свой IO к вшитому IO
>>1794268
И какие в этом проблемы? Суть фп в том чтобы уменьшить количество багов и успокоить свои нервы, какое мне дело до каких-то костылей если я уверен что код в 100% случаях будет работать как надо? Особенно если юзать зависимые типы
С помощью unsafePerformIO :: IO a -> a можешь написать свой ио.
https://www.youtube.com/watch?v=fCoQb-zqYDI
живу в чехии, седня решил по приколу глянуть вакансии на хаскел ни одной не нашел
Да конечно их нет, язык с высоким к сожалению, даже порог входа в хаскель считается высоким порогом вхождения, рантайм система делает редукции недетерминированно, насколько я помню ее исходники, узкие места по производительности бывает очень трудно предсказать и поправить из-за принципиальных несовместимостей ФП и архитектуры, основанной на Фон Неймановской.
Вот для чего хаскель реально хорош -- для мелких микросервисов, да. Для написания компиляторов других языков. Для академических целей.
Вообще, мелкософт не зря у себя хацкель держит, они на нем обкатывают новые красивые rocket-science штуки и затем внедряют их тихонько к себе в более практические продукты.
Вон, в шарп хотят тайпклассы завезти, наконец-то (хотя шарп лично мне не нравится, ну хоть в f# завезут, уже что-то не то чтобы я на нем активно кодил, лол).
Из практических фп языков взлетают такие, как кложа или эликсир, потому что строгие языки требуют строгого же понимания, что, собственно, за хуйню ты делаешь. А в продакшне никому не хочется ждать, пока ты додумаешься, чего и как настакать из монад и почему вот здесь GADT не дают скомпилиться.
P.S.
У меня больше теоретическое понимание хацкеля (компилятор на нем пишу переписываю), мне он нравится с технической точки зрения, но с продуктовой он не ко всему подходит. С одной стороны, типобезопасность круто, с другой, множество всех допустимых программ больше множества типизируемых на данный момент в любом языке программ, о чем сами авторы хаскеля (Пейтон-Джонс и ко) и говорили, да хоть вот в этой https://www.microsoft.com/en-us/research/publication/outsideinx-modular-type-inference-with-local-assumptions/ статье. Да, я снова приплетаю OutsideIn(X), потому что это самая шикарная статья по системе типов хаскеля из всех, что я читал. Каждый потраченный на ее разбор день прошел не зря.
Причины непопулярности хаскеля чуть более прагматичные чем кажется. Во-первых сейчас много платформ монополизируют языки ради экономии мозгов разработчиков и популяризации самой платформы: в вебе только жс, в продукции эпл свифт, в андроидах жава, итд. Во-вторых хаскелю катастрофически не хватает качественных библиотек и фреймворков, решающих насущные проблемы мира. Дрочить на всякие линзы и хуйпоймиморфизмы увлекательно, но наебашить MVP на коленке просто невозможно: ни документации хорошей, ни самих библиотек, ни сообщества. Для большинства хаскель это невероятно убыточное предприятие, которое не принесёт ничего кроме разочарования. Хаскель пробовали уже миллионы, и что-то ни одной ошеломительной истории успеха ещё не было.
Ну он потому что в первую очередь академический, да. Он больше привлекает, в силу своей природы, людей, ориентированных на те самые линзы, монады и элементы теорката. А у практиков более удобные инструменты под рукой + задачи, которые нужно решать прямо сейчас.
Собственно, я пытаюсь как раз на базе OutsideIn(X) сделать язык, у которого будет практическая ценность + предсказуемость нагрузки, но приходится немного изворачиваться, чтобы модифицировать эту штуку под подобие раста со сборкой мусора и процессами как в erlang. Вряд ли взлетит, конечно, зато есть чем заняться по вечерам :)
Можно создать список списков. Не очень понимаю, что значит "тип" в этом контексте. Информация о том, содержит ли список единицу или другое число, доступна только во время исполнения, а во время компиляции и типизации она не доступна. Тогда наверное нужно создать новый тип чисел и списков?
Твой вопрос не имеет смысла потому что в хаскелле нет примитивов
В хаскелле как языке всё полиморфно, все типы по сути ничем не отличаются кроме своей структуры, всё это никак не трогает реальный мир
Единицу (1) в хаскеле можно реализовать как абсолютно ничего не значащий тип data One = One или data Hui = Hui, можно создать оба типа, идиоматически считать Hui за 0 и One за 1, создать data Bin = Nil | Hui Bin | One Bin deriving Show и писать бинарный код как чистые типы Hui (Hui (One Nil)). Одними лексическими конструкциями возможно навелосипедить и полноценный матан
В рамках хаскелля как языка все числа также являются типами, да и вообще хаскель а-ля лисп, только "эвресинк эс э дата эс э статик тайп сигнатур". Как оно втискивается компелюктором в уровень итогового языка или как оно переводит твои типовые - тебя как разработчика ебать вообще не должно. Int ты можешь воспринимать как data Int = Zero | One | Two ...
До говнометных долбаебов выше не может дойти, что IO в рамках хаскелля как языка- такая же нихуя не делающая простейшая монада, в реальном мире ей приписывает компилятор захардкоженные действия под сигнатуру на конкретно эту монаду. Можете написать свои реал-ворлд действия через ffi под другую монаду, но вы будете писать интерпретатор IO, а не IO. IO как монада IO в хаскеле - тупо пробрасывание туплы, как скопипастил >>1792526
>тип описывающий все списки содержащие только единицы [1,1,1] и т.д
Эта хуйня не имеет никакого смысла с точки зрения типов. Все джва миллиарда инт32 чисел имеют сигнатуру Int, линкед лист тут является сторонней дата структурой-упаковкой и отношения к контенту не имеет
Я не очень понимаю цели. Проверяй ручками, соответствует вставка дырке или нет. Чё ты напредставлял, чтобы оно по каким-то типам магически подгоняла данные в рантайме - хуй знает https://dpaste.com/F8UEQH7XM
Можешь еще создать сразу дату со структурой линкед листа вместо отдельной сувания даты в отдельную линкед лист структуру , если полиморфизм тебе не нужен
>Есть какое-то исследование, что ФП уменьшает количество багов?
Есть только экспертные оценки. Реально такое исследование провести практически не возможно, потому что нет формальных критериев, по которым можно считать баги.
>Критичное ПО для самолётов/атомных станций/подводных лодок пишут на ФП?
Нет, его пишут на асме и C и тестируют до посинения. В таком ПО не важна стоимость разработки, но важно, чтобы оно работало на однобитном процессоре, собранном из чугуна и гаек. Реактивные двигатели вообще запускают с помощью "контроллеров", выточенных на токарном станке. Там кулачковый механизм замыкает контакты в определенной последовательности.
ФП нужно для того, чтобы можно было быстро слепить что-то более-менее рабочее не прилагая слишком много усилий. Если тебе нужно написать ПО для самолёта, всегда есть возможность нанять миллион программистов и тестировщиков и протестировать 10 строк кода вообще на всех возможных вариантах или не всегда https://ru.wikipedia.org/wiki/%D0%90%D0%B2%D0%B0%D1%80%D0%B8%D1%8F_%D1%80%D0%B0%D0%BA%D0%B5%D1%82%D1%8B-%D0%BD%D0%BE%D1%81%D0%B8%D1%82%D0%B5%D0%BB%D1%8F_%C2%AB%D0%90%D1%80%D0%B8%D0%B0%D0%BD-5%C2%BB_(4_%D0%B8%D1%8E%D0%BD%D1%8F_1996_%D0%B3%D0%BE%D0%B4%D0%B0)
>рантайм система делает редукции недетерминированно
Ну нет, естественно детерминированно. Просто хуй проссышь как именно, потому что алгоритмы оптимизации слишком сложные. Кстати, llvm и gcc тоже оптимизируют хуй проссышь как именно, и когда нужна очень хорошая оптимизация, все тоже сводится к ручному подбору. Можешь глянуть на это дрочилово https://github.com/Cyan4973/xxHash/blob/dev/xxhash.h
Задача любого высокоуровневого языка не в том, чтобы программист досконально понимал, как его программа переводится в ассемблерный код а ведь даже если будет понимать, в любом современном процессоре хуй проссышь как работает кешь, префетч, тротлинг и бранч-предикшн, ты даже на асме рискуешь словить неожиданную просадку производительности https://blog.cloudflare.com/on-the-dangers-of-intels-frequency-scaling/ а в том, чтобы среднестатистическая программа работала более-менее нормально.
Я думаю, что можно считать, что Хаскель примерно раза в 3 медленнее сишки в среднем по больнице. Да, в каких-то местах его можно разгонять до скорости сишки, но это очень больно, нестабильно и делается путём проб и ошибок. Но и сишка не очень-то стабильна в плане перформанса и когда там на экстремальную производительность выходят, тоже очень ебуться. Поэтому на Хаскеле надо тупо писать в идиоматичном стиле. Часть потенциальных оптимизаций проебётся, часть сработает, в среднем будет треть производительности от сишки, если такая производительность устраивает, то почему нет?
Ну, экспертные оценки -- это хорошо. Вероятно, это уважаемые эксперты. Тогда дяди, у которых есть любой разумный бюджет, запрос на 99.999999% надёжность их АЭС или стратегического бомбера, вероятно массово нанимают Хаскеллистам.
И значит, Хаскелл доминирует в этом небольшом по численности, но очень важном и небедном сегменте? Хотя ой, это не так. Всё ещё надёжнее тестировать код на сишечке.
Т.е. ФП не очень-то выходит нужно там, где реально нужна надёжность, и ещё менее нужно для сайтов на вордпрессе. Куда не перекатывайся -- нахуй там нужно ФП, sad but true
ЯВУ
>HLPL
А Haskell - это VHLL.
https://en.wikipedia.org/wiki/Very_high-level_programming_language
>Просто кто-то даёт байтоебствовать (си
Ага, "даёт". В случае с говняшной у тебя никакого выбора нет.
>>1810320
>Cи явл
Today, many programmers might refer to C as low-level, as it lacks a large runtime-system (no garbage collection, etc.), basically supports only scalar operations, and provides direct memory addressing. It, therefore, readily blends with assembly language and the machine level of CPUs and microcontrollers.
https://en.wikipedia.org/wiki/High-level_programming_language
Ключевое это
with a very high level of abstraction
Бтв, в русскоязычной статье Haskell указан.
К языкам сверхвысокого уровня также часто относят такие современные сценарные и декларативные (в частности функциональные) языки как Python, Ruby, Haskell
https://ru.m.wikipedia.org/wiki/Сверхвысокоуровневый_язык_программирования
Пробуй разные источники и выбирай наиболее подходящий для тебя вариант.
Основные идеи синтаксиса Хаскеля довольно простые. Другое дело понять принципы построения на них более высокоуровневых конструкций и привыкнуть к ним, чтобы уметь их читать и понимать.
> есть ли какое-нибудь другое пособие, где все более менее медленнее разжевывается?
Можешь попробовать LYAH - Learn You a Haskell for Great Good.
Многие вступительные пособия по Хаскелю совсем ничего не говорят о конкурентности, наверное это потому что они фокусируются на особенностях и отличиях Хаскеля от других языков, но помимо киллер-фич и университетских пэйперов есть ещё и архитектурные вопросы, а также обычные повседневные задачи. Тебе может помочь в этом книга parconc - Parallel and Concurrent Programming in Haskell (можешь сразу начать со второй части).
Ещё случайно наткнулся на книгу The Monad Book, книга хорошо объясняет такие темы как монады, трансформеры монад и т.д.
1. Отсуствие вменяемой ide в 2k20.
2. На нем сложно пердолить код. Когда дедлайн неделю назад быстро говнокодить костылями.
Ну т.е. когда у тебя неограниченный ресурс времени и ресурсов - как например при написании конпелятора хаскеля, то да, вдумчивое медленное написание кода на хаскеле приводит к отличным результатам. Когда у тебя задача типа конпелятора хаскеля, символьных вычилсений, то использование Хаскеля будет преимуществом. Когда у тебя тырпрайзная императивная лапша с логированием, обработкой всевозможных ошибок, кучей состояния как локального, так и на сервере, то использование Хаселя будет адом.
Все верно. К тому же очень очень трудно оценивать производительность получившегося кода. Выше по тексту аноны не сошлись во мнении так все-таки будет меморизация или нет в коде из двух строчек. А если таких строчек 2000, 20000? Очень все непредсказуемо. Нужно быть разработчиком компилятора, чтобы точно знать какая сложность будет у кода. Из-за этого невероятно трудно оптимизировать - нужно знать миллиард ньюансов. Часто оптимизации сводятся к unsafe модификациям - можно посмотреть тут https://benchmarksgame-team.pages.debian.net/benchmarksgame/fastest/ghc-fsharpcore.html. Часто даже яву обгоняет - но по сути это достигается тем что Хаскель за счет unsafe-ов и указателей превращается в корявую Сишечку.
Из-за того что это не мейнстрим, биндинги к популярным библиотекам появляется через годы и хз как поддерживаются.
До последнего время компиялтор под Винду не генерировал оптимальный IO код. Насколько я помню там не было асинхронного ввода-вывода под винду. Не знаю решили это в последних версиях или нет.
Так-то Хаскель охуенный язык, как творение человеческого разума.По фичам он уделывает любой другой язык программирования. Но он не для того чтобы на нем пердолить, что явлется 99.9 % задач в программировании.
Возражу. Производительный код в целом писать дорого. См. абзац "Complexity" здесь https://matklad.github.io/2020/09/20/why-not-rust.html
То есть, на хаскеле надо именно что ебашить и не думать какое оно там будет по производительности. Большинство энтерпрайзов именно так и делает, максимум компетентности это различать Vector/Map, оптимизировать запросы в БД и делать код который не очень дорого расширять.
> По фичам он уделывает любой другой язык программирования
Ну я бы так не сказал. Хаскель хорош дистинктивностью: только у него весь пользовательский код чистый, а грязь уходит в рантайм, который как бы спрашивает код как чистую функцию, что же сделать следующим шагом. Думаю будущее будет за гибридными языками, где отдельные функции или блоки кода можно размечать как чистые. А тотально выворачивать всю программу в чистую функцию вряд ли настолько нужно и важно.
> Как обработать деление на ноль без эксепшенов
Передавать ошибку явно. Как в Goвне.
> А убить дочерний тред?
Сделать кастомные стратегии вычислений. То есть напрямую генерировать стек.
Представь что ты можешь не только указать компьютеру что сделать, но и как это сделать, и применять разные методы решения на одном и том же коде. Причём всё это будет декларативной и иммутабельно.
> А обработать Ctrl-C?
Опять же стратегии.
> В скриптинге попизже петухона
> хаскелл
Эксепшены в Хаскеле есть.
В книге parconc это хорошо объясняется.
Есть функция throw:
throw :: Exception e => e -> a
Как мы видим из её сигнатуры, она как будто возвращает значение типа а, при этом тип а может быть любым типом.
Как я понимаю, это нужно для таких случаев, когда при ветвлении if-else одна ветвь выполняет работу, а другая выбрасывает эксепшен. Хаскель требует, чтобы обе ветви возвращали значение одного типа, поэтому throw возвращает любой тип.
Действительно, есть в этом что-то императивное.
Отлавливать ошибку можно через catch или через try:
catch позволяет создавать конструкции, похожие на try-catch из императивных языков:
catch :: Exception e => IO a -> (e -> IO a) -> IO a
используя try, можно перейти из неявной (необозначенной типами) обработки ошибок в явную:
try :: Exception e => IO a -> IO (Either e a)
Ну и есть более высокоуровневые функции как onException, bracket, finally.
Есть ещё асинхронные эксепшены, там свои тонкости.
Из https://en.wikibooks.org/wiki/Haskell/Control_structures
Note that in Haskell if is an expression (which is converted to a value) and not a statement (which is executed) as in many imperative languages.[1] As a consequence, the else is mandatory in Haskell. Since if is an expression, it must evaluate to a result whether the condition is true or false, and the else ensures this. Furthermore, <true-value> and <false-value> must evaluate to the same type, which will be the type of the whole if expression.
Если хочешь выполнять (или описывать) действия в ветвях if-else, то обычно они имеют тип IO (), и нужно просто проследить, чтобы обе ветви возвращали IO (). Можно выполнить действия и в конце добавить return (), чтобы тип был какой нужно.
Можно в разных ветвях вызывать разные конструкторы одного ADT. Например, Left и Right для Either, Just и Nothing для Maybe, или написать свои ADT.
Ой да шо вы пиздите. На хаскеле можно писать эффекты, на хаскеля нельзя писать побочные эффекты.
И по сути, в энтерпрайзе с dependency injection все то же самое. Системы эффектов в хаскеле решают те же задачи, что и di в шарпе.в шарпе ты описыввешь интерфейс с необходимыми эффектами, в хаскеле тайпклас. В результате шо там, шо там, одни инстансы юзают для юнит тестов, другие для реальной работы Единственное отличие - на шарпе ты можешь в любой функции вызывать сырой IO говнокод и никто это не заметит, а в хаскеле это будет видно по сигнатуре функции.
Я вообще понял, что намного важнее качество кода и его стурктура, чем язык, никакое фп тут ни при чем. возможно, это неправда для го или динамикоязыков, но я на них не собираюсь писать Да, на джаве надо ебаться с наллами хотя есть Optional<>, да, тут нет красивых линз и сложно писать свой dsl. Но кому это всралось, когда ты пишешь просто вебсайт, с чем справляется что хаскель, что джава, но на джаву есть тонна либ, комьюнити и поддержка? Поэтому хаскель и непопулярен. А еще потому что оброс тонной мемов о страшных монадах и эндофункторах.
> Каким образом ты абортируешь тред
В модели укажу, когда абортировать.
>>1812422
> Есть что-то аналогичное в других языках?
В логических языках программирования такое повсеместно встречается. Связано это с многими фактами. Иначе просто невозможно описать предикаты высшего порядка (такие как findall, forall).
Предикаты как альтернатива типам - это что-то новое, в первый раз такое слышу.
Не представляю язык с предикатами вместо типов. Что это за язык такой?
Ну а вообще, типы (принадлежность к типу) можно считать разновидностью предикатов, которые проверяются во время компиляции.
Обычно предикаты проверяются во время исполнения (require в scala, guard в хаскеле, assert).
Если хочешь, чтобы предикаты проверялись во время компиляции, выражаешь их с помощью типов.
Можешь привести примеры предикатов, которые проверяются во время компиляции, но не являются типами?
Такие вещи проверяются во время исполнения, в системе типов проверку можно выполнять в конструкторе или в какой-то функции.
Это обычный предикат, который проверяется во время исполнения. А я просил пример предиката, который проверяется во время компиляции и не является типом.
>когда подгружаем модуль / выполняем eval.
То есть можно попрощаться с нормальным статическим анализом.
>выполняем eval
Который запускает ракету с ядерным зарядом.
Как я понял, он принимает на вход строку. Почему? Если тебе заранее во время компиляции известны все варианты строк, которые могут прийти, то можно перечислить их в каком-нибудь enum-е, и получишь проверку предикатов через типы.
Если все варианты строк заранее не известны, выходит, проверка осуществляется во время исполнения.
В ФП роль стратегий берут на себя монады, говоря как выполнять код.
>>1813163
Я так понял, что стратегии работают там, где нужно распараллелить вычисления, когда каждое из них изолировано от окружающего мира, вычисления не добавляются и не удаляются динамически, а задаются моделью, которую можно всю вычислить последовательно.
Например, у тебя есть какое-то дерево, ты можешь провести вычисления последовательно, но ты хочешь разделить дерево на две половины и запустить параллельно вычисления для каждой половины.
А есть вещи, которые ты в принципе не можешь вычислить последовательно, тогда уже ты не можешь воспользоваться стратегиями. Правильно?
> Который запускает ракету с ядерным зарядом.
У военной техники память 16кб. Так что оставьте свои влажные фантазии о том что Хаскелле где-то там используется в серьёзных отраслях.
> Если эмулировать пользователя функцией,
В большинстве случаев эмулировать не приходится
Дебильность — легкая степень малоумия (IQ от 50 до 75). Её трудно отличить от психики на нижней границе нормы. Поведение дебилов достаточно вменяемо и самостоятельно, речь развита. Поэтому дебильность замечается не сразу, а обычно в процессе начального обучения. В подростковом возрасте, когда дебильность особенно проявляется, обнаруживаются дефекты в абстрактном мышлении. Дебилами все понимается буквально, переносный смысл пословиц, метафор не улавливается.Лица, страдающие дебильностью, овладевают преимущественно конкретными знаниями, усвоение теоретических им не дается.
>У военной техники память 16кб
Военная техника - это не только анало-говнеты и прочие попытки удержать загибающиеся совковые производства клонов западных микросхем 70х-80х от превращения в склады для Ашотов.
https://www.flir.com/applications/government-defense/
https://gdmissionsystems.com/products/airborne-systems/advanced-mission-computer
И даже у анало-говнетов 16кб можно встретить разве что в рухляди со складов.
http://mniirip.ru/sites/default/files/articles/katalog_elektronnogo_napravleniya_rpkb.pdf
Сынок, ты не понял. Это — борда для обсуждения ковариантных функторов, анафорических макросов, пандорических захватов, кластеров метапарадигм, катаморфизмов, эпиморфизмов, анаморфизмов, параморфизмов, ненужности математики, наконец. Никого здесь твои слесарские проблемы не волнуют. Ваш жалкий практический земной мирок не нужен. Съеби.
Надо было лучше байтойобство изучать.
> Значит это что-то из мира Лиспа?
Ну, обычно в Лиспе так не забываются. Да и AST редактируют только во время макро-экспажена. А вот в Прологе да. Свобода во все поля. И кстати, пересчитывать программу, когда данные(=программа) мутируют не нужно. В Прологе все завимости будут и так считаться, ибо там данные ничем не отличаются от кода.
data(c, C) :- data(a, A), data(b, B), C is A + B.
:- assertz(data(a, 5)).
:- assertz(data(b, 6)).
Так полностью согласен: реально сложная задача, при том идеально подходит для языка: сайдэффекты минимальны, почти чистая функция, хотя и очень сложная, из одних данных в другие.
Но заметим, даже для этого спектра задач "написание компилятора" хаскелль не получил какой-то популярности, т.е. реально самоподдув.
линзы и призмы? тардис монаду? монадологию Лейбница? Накидайте список баззвордов короче, которые стоит освоить, чтобы быть модным борщехлёбом.
В прологе за такую Швабодку приходится платить неэффективностью кода, который сам себя модифицирует, и чуть меньшей эффективностью и заметно большей сложностью системы в целом.
Помню смешной sbprolog, где retract занимался декомпиляцией, чтобы восстановить фразу.
Пиздец, как вы это пишете вообще. Какие то монады, говнады, выражения странные, лямбды через строчку, синтаксис ебейший.
https://downloads.haskell.org/ghc/9.0.1-alpha1/docs/html/users_guide/9.0.1-notes.html
Алсо поясните за ональную модерацию. В pr/ уже тупо банят за создание треда?
>>1838974
Т.к. ты не задал конкретного вопроса, привожу краткое пояснение.
Стейт это про функцию, которая получает состояние и возвращает какой-то результат и изменённое состояние.
func :: s -> (a, s)
Если обернуть эту функцию в какой-то тип и сделать этот тип монадой - получишь монаду стейт. Дальше создаешь функции для чтения и изменения состояния get и put.
> ппц чёт торможу
в каком месте ты тормозишь?
>Что это за состояние
В школе на алгебре переменные проходили? Ну так вот, если кратко, то состояние - это всё что угодно, что можно выразить через переменные.
> в чем оно выражено/чем представлено
Состояние может быть выражено/представлено любым значением, а в Хаскеле у значений есть тип, поэтому ответ такой: значениями и их типом.
- Удовлетворить своё любопытство
- Не быть лохом, когда пацаны обсуждают что-то функциональное возле кулера, а мне не то, что сказать нечего, я не понимаю ничего даже
- У знакомого есть вакансия, где неплохо бы немного знать хаскеля
Сейчас я из функционального знаю только что такое лямбды в пайтоне и что есть мап, редюс и фильтер.
Мне лучше читать SICP чтобы врубиться в функциональную терминологию и это вот все, а потом учить хаскель, или есть сразу книга по хаскелю, где написано всё для тех, кто вообще раньше с функциональщиной не связывался?
Ну вообще через каррирование функций можно сделать вычисления ленивыми. Ну кое какие типы есть. Есть целые либы под ФП на JS, так что там достаточно для этого функционала. А во вторых не я язык выбираю, пилю небольшой проект на работе решил в нем ФП попробовать
Вообще ФП ахуенно. Сначала видел много неудобств. Но когда втянулся, начал доканчивать свои проекты на ООП, начал понимать, что все слишком сложно, и на ФП проще.
> Ну вообще через каррирование функций можно сделать вычисления ленивыми.
Таки да. Можно к тому же эмулировать стейт через каррипование.
start(
entity ("id0") (Player),
set ("id0") ("x") (10)
set ("id0") ("y") (10)
)
Где:
start (... Function) -> State
entity (String) (Component) (State) -> State
set (String) (String) (State) -> State
А что не в жс треде?
> у нас структура типа такой maybe(either(maybe(a))). Как это все объединить?
использовать pipe оператор
> either(maybe(a))
> maybe(either(..))
Это все можно флэтить, в зависимости от того, какое значение тебе нужно в процессе и какое на выходе. Вообще, должны быть операторы типа either.fromMaybe/maybe.fromEither
> И вообще считается ли полная распаковка монад до значений хорошей практикой?
it depends, но вообще нет. Есть же фолд.
>Как быть с вложенностью монад
Не допускать. maybe(either(maybe(a))) - очень плохой пример и некоторые быдлокодеры реально так пишут, поверь, я знаю, о чём говорю.
Давай его разберём.
Тут, скорее, вызов функции, которая возвращает результат либо пустое значение, затем Either, чтобы сигнализировать об ошибке, затем снова Maybe, наложенная каким-то следующим слоем обработки данных.
Что можно сделать? Во-первых, убрать Either. В языке и так есть исключения для сигнализирования об ошибках, просто используй исключения. Остаётся 2 Maybe. Но вызывающей стороне пофиг, в каком слое не оказалось значения. Ей вообще лучше ничего не знать о внутренней структуре, поэтому просто схлапываем в один Maybe.
Потом думаем еще раз, является ли Nothing нормальным результатом? Если это, например, функция получения значения из кеша, то оставляем, пусть возвращает Nothing, если значение не найдено. Но если это функция получения пользователя из базы данных, то наверняка лучше просто возвращать пользователя, или кидать исключение, если он не найден. Получается, что мы просто возвращаем a.
Наконец, осознаём, что наша функция скорее всего имеет какие-то побочные эффекты, поэтому будет IO a. Но еще она работает в каком-то окружении, поэтому будет ReaderT MyYobaEnvironment IO a. Но еще мы не хотим жеско зашивать окружение для возможности использования различных окружений, тестового и продуктового, например. И не хотим показывать функции, что она ранится в ReaderT MyYobaEnvironment IO, потому что это опять же детали реализации. Поэтому определяем кастомную монадку MyYobaMonad, содержащую все необходимые сервисы, и итоговую сигнатуру функции f :: (MyYobaMonad m) => m a. В результате монадка используется только для контроля окружения и побочных эффектов.
Практические рекомендации как использоать монадки в приложениях здесь https://www.fpcomplete.com/haskell/library/rio/ для Хаскеля, здесь https://degoes.net/articles/zio-environment для Скалы.
>Это обязательные условия для использования монад?
В целом - да. Обрати внимание, в своём предыдущем посте я писал только про сигнатуры функций. Т.е. он как-бы весь про типы. Какой профит городить конструкции, которые на 99% про типы в безтиповом языке? Ничего не получишь, да еще и синтаксисом наебёшься.
>Огласите полный список, пожалуйста.
1. Чистота. Хотя бы номинально. Посмотри на дизайн в ZIO, там вся грязь заворачивается в монадки, потому что если мешать чистый и грязный код втупую, профиты резко улетучатся. Но ладно ZIO, там уже за тебя всё завернули, а если ты берешь обычный язык с сайдэффектами, ты что ли будешь самостоятельно писать врапперы для всех библиотечных функций?
2. Ленивость. Вот Scala - не ленивая, и какая-нибудь конструкция на ZIO вроде for { _ <- putStrLn(s"Hello ${yoba.toString()}") } yield () кидает фатальную ошибку, если yoba.toString() выкинет исключение. Приходится писать что-то вроде for { q <- ZIO(yoba.toString()); _ <- putStrLn(s"Hello $q") } yield ().
3. Оптимизация хвостовых вызовов. Для реализации flow-control монадок. Потому что внутри они выглядят примерно так: newtype M m a = M { unM :: forall r . (a -> m r) -> m r } И биндинг примерно так: M ma >>= fb = M $ \k -> ma $ \a -> unM (fb a) k, но это будет работать только если в языке есть оптимизация хвостовых вызовов. Собственно всякие ZIO потому и существуют, что в Scala оптимизации хвостовых вызовов нет и прходится изрядно поебаться, чтобы сделать flow-control монадку.
4. Специальный синтаксис. Это for { q <- ZIO(yoba.toString()); _ <- putStrLn(yoba) } yield () - пиздец какой отстой по сравнению с этим: putStrLn (show yoba)
>>1827115
Это не Хаскель сдох, это /pr сдох. Ссыкуха-модер всех рассадил по номерным тредам и трёт любые PLT-срачи. А нахуй мне сидеть в треде по Хаскелю? Помогать школьникам делать домашки? Так есть Stack Overflow, есть Хабр, блядь. Да даже на Хабре можно написать более провокационную статью. Нслаждайся беззубой хуйнёй в которую превратился pr и обсуждай домашки по php и собеседования в номерных тредах.
Ты потыкай любой другой стиральный порошок и потыкай в Хаскель. Сразу поймешь, в чем разница. Или не поймешь, если не программироал.
>>1853691
Начинай с The Haskell School of Expression дальше читай Typeclassopedia (http://www.haskell.org/wikiupload/8/85/TMR-Issue13.pdf), дальше статьи по ссылкам в тайпклассопедии, викикнигу (http://en.wikibooks.org/wiki/Haskell), а точнее отдельные главы. Ну и вики на haskell.org.
Некоторые няшечки могут посоветовать Душкина (беги от этой книги, как от чумы), Грема Хаттона или "Изучи себе хаскель во имя великой справедливости" - не слушай их, только напрасно потратишь время.
Ну а после изучения нормального языка программирования уже сам решишь, нужен ли тебе этот самый питон.
https://www.seas.upenn.edu/~cis194/spring13/lectures.html
И даже не знаю с чего начать. Смотрю солюшен с гитхаба вижу буковки и не понимаю что они делают.
Что делать? Посмотреть гайды с ютуба недельку или хаскель не для меня?
Лучше поздно, чем никогда. Наверное.
В качестве "случаев" для сравнения case могут выступать только конструкторы.
> case foo of
> 3 -> a -- "" - конструктор пустой строки
> x -> x * 2 -- x - не конструктор, так что сравнения не происходит
можно трактовать как
> если foo = "" - верни a
> если foo - что-то другое, то назовём это 'другое' буквой х и умножим на 2
Так вот s' в том case выражении - присвоение результата 'dropWhile Char.isSpace s' идентификатору s', если этот результат не "замэтчился" в вышеуказанных случаях.
Затем, чтобы типобезопасность была.
Хочется безопасно взять голову списка: `safeHead :: [a] -> Maybe a`
Почему не `[a] -> Either Exception a`? А нафига. Нам и так известно, что она может пофейлиться, и даже точно известно, на чем именно.
Maybe через Either с допиливанием (до бифунктора, битраверсабла) выразить можно, наоборот - нельзя.
Едем дальше. Task и Either.
Чувствуется разница между `giveMeUserPlease :: Login -> Task User` и `giveMeUserPlease :: Login -> Task (Either UserNotFoundError User)`?
Этот Task может пофейлиться и это вынесено на уровень типов, всё явно.
Так что теперь забыть обработать ошибку инструментарием тайпклассов уже не получится.
Task и Maybe
`lastUserMessage :: User -> Task (Maybe Message)` против `lastUserMessage :: User -> Task Message`.
Всё бы хорошо, но нам вовсе не факт, что нужно, чтобы в случае, если сообщения нет то всё фейлилось.
В своём красивом домене мы вполне можем ожидать того, что сообщений нет, и штатно обработать этот случай, не как ошибку.
Но если скрыть Maybe под капотом, то начинаются танцы с тайпклассами, и типобезопасность уходит от нас.
Я раньше не понимал, почему вас недалёкими сектантами называют, а теперь вижу живой пример.
https://tsar1997.blogspot.com/2020/05/blog-post_2.html
шиз-то прав оказался!
Вот чем слесарь отличается от инженера. Инженер проектирует, а слесарь выполняет. Инженер должен что-то придумать, а чтобы придумать, надо думать уметь. А слесарь не должен думать, он должен уметь пользоваться инструментом, и ни в коем слечае не думать, а то вдруг придумает что-то другое, а не то, что ему сказали сделать. Слесарь не инженер, он гордится только тем, что умеет пользоваться инструментом.
А теперь посмотрите на толпу хаскелистов и любого энтерпрайзного инженера. Инженер проектирует! У него для этого есть методологии проектирования, парадигмы проектирования, OOD, DDD, даже паттерны у него не чего-попало, а паттерны проектирования, блд! А что хаскелиисты? Зайдите в любой чат и сразу увидите. Хаскель для них все лишь интрумент, они обсуждают сам этот инструмент, никакого проектирования, и им нечем гордиться, кроме своего умения в этот инструмент. Потому что слесари, сласари!
спасибо
а не можешь начинающему пояснить за вот такую проблему?
type Point = (Int,Int)
line_0 :: Point -> Point -> [Point]
line_0 (xa,ya) (xb,yb) = map (\p -> (round (fst p), round (snd p))) [((xa(1-t)+xbt), (ya(1-t)+ybt))|t <- [0, 0.01 .. 1]]
дает ошибку No instance for (RealFrac Int) arising from a use of ‘round’ и прочая и прочая. Я как бы и понимаю, что беда в типах, но как это исправить? То есть как реализовать преобразование типов так, чтобы это дело не ругалось?
Скорее всего есть более правильный способ, но код ниже хотя бы компилируется.
Нашёл такое пояснение: https://stackoverflow.com/a/19019707/8569383
type Point = (Int,Int)
line_0 :: Point -> Point -> [Point]
line_0 (xa,ya) (xb,yb) = map (\p -> (round (fst p), round (snd p))) lst
where
ts :: [Double]
ts = [0, 0.01 .. 1]
lst :: [(Double, Double)]
lst = [(( (fromIntegral xa)(1.0-t)+xbt), ( (fromIntegral ya)(1.0-t)+ybt))|t <- ts]
xbt = 1
ybt = 1
мимопроходил
```
import Control.Arrow (())
type Point = (Int,Int)
line_0 :: Point -> Point -> [Point]
line_0 (xa,ya) (xb,yb) =
map (roundround) [(f xa xb t,f ya yb t) | t <- [0, 0.01 .. 1]] --
where
f :: Int -> Int -> Double -> Double
f a b t = fromIntegral a (1 - t) + fromIntegral b t
```
Во-первых знак умножения писать надо. Т.е. вместо ybt надо писать yb * t.
Во-вторых, нельзя умножить Double или Float на Int, или сложить, например.
Большинство операций работают только с аргументами одного типа.
Т.к. ты использовал [0,0.01..1], то благодаря литералу 0.01 тип этого выражения уже не [Int], а [Double] (или [Float], или еще какая вещественная дребедень).
Есть операции приведения к нужному числовому типу. Из целого в вещественное можно переводить функцией fromIntegral.
В третьих используй `where` или другие штуки, чтобы не превращать код в нечитаемое месиво.
Например, как я вынес тяжелое мозолящее глаза выражение из list comprehension прямиком в where блок, обозвав это функцией f.
```
import Data.Bifunctor (bimap)
type Point = (Int,Int)
line_0 :: Point -> Point -> [Point]
line_0 (xa,ya) (xb,yb) =
map (bimap round round) [(f xa xb t,f ya yb t) | t <- [0, 0.01 .. 1]] --
where
f :: Int -> Int -> Double -> Double
f a b t = fromIntegral a (1 - t) + fromIntegral b t
```
пофиксил, т.к. импортнутый из Arrow оператор не отображался