Оп-хуй. В прошлом треде прикрепил Нэша, теперь Перельмана.
От себя посоветую книгу
Christopher Allen, Julie Moronuki Haskell Programming from first principles
Она мне больше Real World Haskell понравилась

>>969781
Спасибо, приебеню к следующему.
От себя рекомендую задачки на codewars для практики.

>>970711
Чё сразу секта? Тред не очень активен, но в нём пишут. Другое дело, что много постов типа : "Зачем этот ваш хаскелль нужен?", "В чём суть ФП?", "ООП говно", "ФП говно".

Давеча открыли Хачкиль-код в продакшоне:
https://github.com/wireapp/wire-server

>>970711
Да в принципе есть народ, в следующем треде сделаю нормальную шапку, с ссылками на задачки.

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

>>970815
>наследование мандадки от аппликатива уже завезли?
Да

Чо такое гомоморфизм, функтор, моноид, Абелевая группа и зачем концептуально они нужны?

>>970872
Хуетень чтобы тешить чсв.

>>970872
изучая эти понятия ты одновременно изучаешь все реальные обьекты которые обладают свойствами заданными в определениях
например если твоя мамка удовлетворяет свойствам функтора то к ней применимы все теоремы о функторах

>>970872
> моноид
Какая-то библиотека может автоматически распараллелить код, как только увидит моноид, так как там операция ассоциативна

Надеюсь Вы мне сможете помочь. Я написал прогу, которая считает функцию Неймана, в качестве аргумента она принимает комплексное число, суть вопроса: как передать в качестве аргумента, список чисел от 0.0+1i до 14.0 + 1i, как вы видите, мнимая часть всегда равна 1.
Конструкция данного вида:
mapM_ print([(bessY 0 z 100) | z <- [0.1,0.2..14.0]])
Здесь 0 - порядок, z - аргумент, она выводила значение ф-ии Неймана для аргументов от 0.1 до 14.
Она работала, но в таком случае аргумент был вещественным числом, а надо, чтобы был комлпексным.

>>971036
Разобрался сам.

А я напоминаю, что вторая часть уже началась https://stepik.org/course/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5-%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5-%D0%BD%D0%B0-%D1%8F%D0%B7%D1%8B%D0%BA%D0%B5-Haskell-%28%D1%87%D0%B0%D1%81%D1%82%D1%8C-2%29-693/

>>969781
Буду накатывать эту книгу в свободное время. Мне хуёвенько и все надоело, хочу прикоснуться к прекрасному.
А нихуя остальные его учат, интересно?

Куда мне путь если я изучу Haskell? Куда я смогу заделаться? Математику знаю, но на уровне двух курсов вышки в относительной шараге.

Всем ли доступен хаскель?

>>973511
Только по спец. разрешениям.

>>973522
А гуманитарии осилившие жабу, способны ли осилить Хаскель?

>>973525
Вполне, но будь готов, что от всех других языков тебя потом будет тошнить, от Жавы в первую очередь.

>>973541
А от Ассемблера? Тоже ЯП жеж.

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

>>973558
Значит, ты не дучил хаскель.

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

>>973590
Удваиваю.

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

Поясните, во что разворачивается эта хуйня:
fibs = 1 : scanl (+) 1 fibs

Не сам результат, а как происходит вычисление. Я всю голову сломал. То есть, 1 :, потом идет scanl, но он вызывает fibs, где снова идет 1:. Как это работает?

Если кто пропустил, с февраля начала выходить вторая часть видеолекций о теории категорий для программистов
https://www.youtube.com/playlist?list=PLbgaMIhjbmElia1eCEZNvsVscFef9m0dm

>>973676
http://hackage.haskell.org/package/base-4.9.1.0/docs/Prelude.html#v:scanl :
scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]

>>969768 (OP)
наконец-то норм шапка

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

>>973787
Кобол.

>>973794
Так у него другая парадигма же.

>>973590
чистоты и ленивости

Почему у Хаскелла такой сложный синтаксис? Он конечно еще легче, чем у Rust'а, но все-же.

>>975406
Не сложный, а минималистичный.
Кресты местами намного блевотнее выглядят.

>>975409
А нет чего-то такого эдак однородного? Вот в лиспе мало всяких странных символов и все однородное, а что-то подобное но отвечающее нормам 21 века (монадки, функторы, зависимые типы) нельзя сделать?

>>975413
scala

>>975722
Но это не чистый функциональный язык по сравнению с хаскелем офк

>>975406
для начала важно разобраться с инфиксными операторами и паттерн-матчингом
остальное дело привычки
и да, пробел – оператор аппликации

а по факту ты очень удивишься насколько он читабелен и понятен

>>975990
Он == Haskell
Rust читался мною более менее, но потом начались лайфтаймы и это ебануться!

>>975406
Сходи, почитай значение слова "синтаксис", потом кукарекай.

Ну что блин ему не так?

>>976254
>Sublime Text

>>976254
Нахуй его, у меня вообще Repl перестал открываться через пару дней использования.

Собственно можно использовать Idea Community Edition + Haskell plugin, если памяти в системе достаточно.

>>976426
Ты можешь объяснить, сколько будет учиться хаскель до вменяемого состояния, при ежедневном изучении в часов так по 10 в сутки?

>>976428
Так от бэкрграунда зависит. Кто ты, непонятно - школие или тырпрайз макака или вкатыватель какой. Кроме того, 10часовое задрачивание ни в чем пользу не принесёт, важно чередавать активную и фоновую работу мозга, максимально интенсивно загрузить его и отвлечься на другие задачи, чтобы он скрипел в фоновом режиме. У Пуанкаре об этом где-то здорово написано.

Делай что должен и будь что будет.

Кстати, можешь попробовать в repl выполнить :set prompt "" - помню из-за бажной реализации очистки экрана, меня бесило что ввод ломался. Может поможет и тебе. Загруженных модулей конечно не увидишь, если это важно.

>>976441
сажа откуда-то

>>976441
Вкатыватель. Ну хоть приблизительно, в диапазон помести.

>>976445
Судя по общению, тебе хачкиль будет даваться с трудом. Попробуй js для начала, потом вернешься или нет

>>976458
PureScript же

>>976254
зачем ты в .hs-файл копируешь ghci сессию,
ты что ебанутый? что ты пытаешься сделать?

>>976497
Лол. До твоего ответа думал, что у него саблайм пытается влезть в REPL и обработать её как .hs-файл. Оказывается это просто скопипащенный REPL.

>>976254
Друг, ты безнадёжен.

Чем код редактируете? Писать без IDE в статически типизированом языке - себя не уважать, собирать своими руками парашу из emacs/vim не хочу.
Для однострочников текстовый редактор пока подходит, но на будущее интересно.
В https://wiki.haskell.org/IDEs одна параша - эклипс тормозное говно и не нужен, сублимы-атомы хуита.
Что можете сказать про жидею с плагином и Leksah?

>>977793
Жидея - кал. Я под атомом и скажу, что не хуже жидеи будет, даже стилистические улучшения предлагает. Но есть один НЬЮАНС. Из-за эпичного проеба в ghc-mod память течёт эпично. Тому в соседней сонсоли у меня запущен
watch -n 15 'pkill ghc-mod'

Так победим!

>>978102
ну и костыль, братишь) а команда прикольная, спасибо!

>>969768 (OP)
Нашел работу с хаскеллем. Дерзайте аноны, монады сила!
кто там ищет иде, гуглите Spacemacs

>>978702
Откуда заказчик? Офис или нет? Какая сфера применения?

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

Заранее спасибо

>>977793
visual studio code с плагином Haskero

>>976493
Это плохой совет. Его постоянно перепиливают и захуячивают новые странные фичи, так что новичку это не надо. Если что, elm лучше для новичка.

>>977793
>собирать своими руками парашу из emacs/vim не хочу
Ну и дурачок. Emacs + intero - сила! Минимальный конфиг можешь найти у сноймана

Я перестал испытывать какой-либо интерес к программированию, когда осознал всю независимость формы и результата. Я люблю области, где форма = результат. В программировании, форма = код. Ты можешь сколько угодно менять структуру своего кода и ксс, можешь хоть обфусцировать и минифицировать его тыщу раз, а результат в браузере от этого никак не изменится. Ценность формы здесь чисто менеджмент-уровня, майнтабельность все дела. Причём, к сожалению, я не могу сказать, что "красивое функциональное решение" выстраданное на хаскеле за неделю всегда майнтабельнее, чем делающий абсолютно то же самое, написанный на коленке за полчаса скрипт на ноде, в котором всё просто и банально... Да и сама майнтабельность это чисто прикладная ценность, нет в ней ничего фундаментального и вечного.

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

Прошу вибачення за вопрос по софту, но: Atom или VSCode?

Я не особо в восторге от сих хипстерских редакторов и кроме как для Хаскеля Atom не использую; Atom мне нравится интеграцией с ghc-mod, показывает типы. Не нравится странным REPL. Файл в него загружать/перезагружать нужно явно, дополнение там идиотское.

>>979205
>>978836

>>979179

Haskell:
(r ^? responseBody . key "collection" . nth 0 . key "track" . key "id" . _Integer) <|> (r ^? responseBody . key "collection" . nth 0 . key "playlist" . key "id" . _Integer)

JavaScript:
(res.collection[0].track || res.collection[0].playlist).id

>>978746
Так и до деанона недалеко.
Смотри тематические сообщества.
Еще есть годная "конфа", там можно задать вопросы и найти иногда работу.
Одно время записывались радио выпуски о хаскелле, разговоры на всякие темы, интервью, обзор новостей и прочее, но сейчас перестали.

Подкиньте плиз задач для ньюфагов

>>979301
>но сейчас перестали
ты про "бананы и линзы"? да вроде ж опять начали

>>979445
на хаскельвики есть 99 задач

>>979702
Благодарю

ПОЧАЛОСЬ
https://jobs.dou.ua/companies/livatek/vacancies/40483/

Почему haskell часто советуют новичкам?

>>980103
Погугли аниме Boku No Pico и игру Battletoads, поймешь.

>>980087
Чтобы индуцировать у человека аутизм/шизофрению, а потом при помощи NLP сделать из него послушного вьябывальщика, полного энтузиазма, который будет пахать не просто фултайм, но ещё и после работы, перед работой, по дороге на работу, и на выходных. Сниматься в рекламе своих технологий и своей компании с искренней улыбкой полной счастья. Потому что люди без серьёзных психических отклонений и незагипнотизированные на успех в 21-то веке работать, вообще, мягко говоря, не любят, и в такую ноулайферскую парашу как программирование их затянуть нереально, хотя в быту они вполне могут писать скрипты, более сложные алгоритмически, чем все ваши ёбаные интерпрайзы.

>>980114
>>980103

>>980114
А что это там бумкнуло?

>>980087
> 30+ years of working experience as a Haskell developer

>>979294
JavaScript:
(res.collection && res.collection[0] && res.collection[0].track || res.collection && res.collection[0] && res.collection[0].track) && (res.collection && res.collection[0] && res.collection[0].track || res.collection && res.collection[0] && res.collection[0].track).id

пофиксил за тебя

>>980227
даже вот так:
(res && res.collection && res.collection[0] && res.collection[0].track || res.collection && res.collection[0] && res.collection[0].track) && (res && res.collection && res.collection[0] && res.collection[0].track || res.collection && res.collection[0] && res.collection[0].track).id

>>979294
Haskell:
r ^? responseBody . key "collection" . nth 0 . (key "track" <> key "playlist") . key "id" . _Integer

>>980227
>>980228
>>980237
Нет, это всё рабочий код. В хаскеле монойд так не получится юзнуть, линзы так не работают, я много чё пробовал, даже тред создавал, максимум в биндинг вынести со строкой на вход типа f "track" <|> f "playlist", причём там тип надо будет указать. В жс мне не нужны эти проверки которые ты дописал, мне нужно исключение, если вдруг в пейлоаде чего-то не оказалось, потому что это исключительная ситуация, ожидаемое поведение - что там всегда будут эти поля.

>>980237
И как это распарсить в мозгу?

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

>>980247
> В хаскеле монойд так не получится юзнуть, линзы так не работают

> stack repl
Configuring GHCi with the following packages:
GHCi, version 8.0.1: http://www.haskell.org/ghc/ :? for help
Loaded GHCi configuration from C:\Users\alex\AppData\Local\Temp\ghci5680\ghci-script
Prelude> import Data.Aeson.Lens
Prelude Data.Aeson.Lens> import Data.Text
Prelude Data.Aeson.Lens Data.Text> import Control.Lens
Prelude Data.Aeson.Lens Data.Text Control.Lens> import Data.Semigroup
Prelude Data.Aeson.Lens Data.Text Control.Lens Data.Semigroup> :set -XOverloadedStrings
Prelude Data.Aeson.Lens Data.Text Control.Lens Data.Semigroup> let t = "{\"collection\": [{\"track\": {\"id\": 42}}]}" :: Text
Prelude Data.Aeson.Lens Data.Text Control.Lens Data.Semigroup> t ^? key "collection" . nth 0 . (key "track" <> key "
aylist") . key "id" . _Integer
Just 42
Prelude Data.Aeson.Lens Data.Text Control.Lens Data.Semigroup> let t = "{\"collection\": [{\"playlist\": {\"id\": 42
]}" :: Text
Prelude Data.Aeson.Lens Data.Text Control.Lens Data.Semigroup> t ^? key "collection" . nth 0 . (key "track" <> key "
aylist") . key "id" . _Integer
Just 42

>>980494
Достойны ответ js-блядку.

>>973558
>скала
блеванул, спасибо, что напомнил

>>975722
блеванул еще раз

>>980114
весело тут у вас

>>980578
>>980575
А чем тебе скала не нравится? Это лучшее их двух миров фп и ооп, где ты сам выбираешь в каком стиле писать.

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

>>980661
Никак.

>>980668
охуеть

>>980661
>>980668
>>980678
http://stackoverflow.com/questions/8676331/how-to-run-a-haskell-file-in-interpreted-mode

>>980696
Нахуй иди.

>>980619
нет чистоты? временем компиляции? скоростью работы? отсталостью средств разработки? синтаксисом наконец?
с хаскелем хоть понятно что это борщехлебство, а скала с претензией.
И блядь синтаксис уродский еще.

>>980805
> а скала с претензией.
Это не скала с претензией, а ее в проде используют, а в остальном

>отсталостью средств разработки?

А идее нормальная поддержка

>синтаксисом наконец?
Вкусовщина

>временем компиляции? скоростью работы?
Ну раз в проде юзают, значит ни критично

>>980813
хаскель тоже используют в проде. Скала конечно популярнее, но тоже маргинальная.
> А идее нормальная поддержка
В идее? Ну вроде норм, только тормозит, хотя это не с идеей связано. Но я вообще-то говорил про ебанутый сбт.
> Вкусовщина
Вспомнил, поблевал.
> ни критично
ясно

>>980494
Да, сработало, я видимо пытался только с (<|>). Но всё равно сложновато, для такой элементарной вещи. В хаскеле вечно приходится думать, напрягать мозги, учить новые инструменты, комбинаторы, для всех тех же задач, которые в обычных яп решаются встроенными конструкциями типа точечки, индексирования, var/let, for/while. Лучше один раз выучить хештаблички, массивы, переменные, ветвления и циклы, и потом уметь выразить на этом любую программу, чем на каждый частный случай придумывать новые комбинаторы и даже парадигмы типа линз и тд. Хаскель позволяет тебе оставаться вечным студентом, ты никогда не можешь его выучить, и за счёт этого он будет удерживать твой интерес, если ты не догадаешься немного абстрагироваться, и подумать, а зачем это всё нужно.

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

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

>для всех тех же задач, которые в обычных яп решаются встроенными конструкциями типа точечки
это до тех пор пока ты делаешь какую-нибудь примитивную тупую хуйню.
чуть усложню твой пример. попробуй сделать это на говноскрипте:
t ^? key "collection" . nth 0 . ((key "track" . key "trackId") <> (key "playlist" . nth 0 . key "track" . key "trackId"")) . _Integer
или
t ^? key "collection" . nth 0 . (key "track" <> key "playlist") . (key "id" <> key "name") . _Integer

>переменные, ветвления и циклы, и потом уметь выразить на этом любую программу
вырази простейшую комбинацию map и filter
Haskell:
map g . filter p . map f

Императивное говно:
let result = [];
foreach (x in xs) {
if (p(x)) result.push(g(x))
}

ой, понадобился еще один фильтр и отображение:
Haskell:
map h . filter q . map g . filter p . map f

Императивное говно:
let result = [];
foreach (x in xs) {
if (p(x)) {
let y = g(x)
if (q(y)) {
result.push(h(y))
}
}
}

и так далее

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

>>981047
> t ^? key "collection" . nth 0 . ((key "track" . key "trackId") <> (key "playlist" . nth 0 . key "track" . key "trackId"")) . _Integer
let firstItem = res.collection[0]; if (firstItem.track): return firstItem.track.trackId; else: return firstItem.playlist[0].trackId;
Оформил в ширину чисто ради большего comedy value. А вообще, я не предлагаю отказываться от map и filter. Если какой-то комбинатор приводит к более компактному и понятному коду и нужен настолько часто, что ты не успеваешь о нём забыть, и тебе не надо его каждый раз гуглить, выгода в его использовании очевидна. Вот если взять fold/reduce, кроме случая когда они используются для расстановки уже задефайненого бинарного оператора между элементами коллекции, они практически всегда приводят к более сложному или даже громоздкому коду, чем цикл с переменными. А частные случаи свёрток кроме map и filter быстро забываются.
> до тех пор пока ты делаешь какую-нибудь примитивную тупую хуйню.
Любая сложная хуйня раскладывается на примитивную тупую хуйню.

Прохожу курс по хаскелю, есть задание

I(1 балл) Следующий рекурсивный тип данных задает

бинарное дерево:data Tree a = Leaf | Node (Tree a) a (Tree

a) Напишите следующие функции:Iвычисление суммы элементов дерева
treeSum :: Tree Integer -> IntegertreeSum = undefined

б) вычисление максимальной высоты дерева
treeHeight :: Tree a -> InttreeHeight = undefined

Я его выполнил, но пришлось добавить поддержку Eq для сравнения, как можно было сделать это иначе, может я какой-то простой способ пропустил, прохожу недавно, последняя тема - алгебраические типы данных, вот мой код. Учу для себя. (не лаба)

https://gist.github.com/Cornpop456/b1aba0581949418672b1f6f061ab6d04

>>981434
Если вместо сравнений (==), (/=) везде использовать паттерн-матчинг, то Eq не понадобится. Код при этом может стать более сложным и громоздким.

>>981459
Понял, спасибо, видимо задание было на паттерн матчинг

>>981434
treeSum :: Tree Integer -> Integer
treeSum Leaf = 0
treeSum (Node as x bs) = x + treeSum as + treeSum bs

treeHeight :: Tree a -> Int
treeHeight Leaf = 0
treeHeight (Node as _ bs) = 1 + max (treeHeight as) (treeHeight bs)

>>981459
>Код при этом может стать более сложным и громоздким
ебанись

>>981467
Повезло. Если б там (==) по делу были, оно бы стало только хуже.

>>981467
Спасибо

Хочется писать на чем-то функциональном и получать за это деньги, что стоит ближе к haskell, как к эталону ? фп, scala или erlang/elixir?

>>981566
Scala - вакансий много и не сказать бы что на ней часто пишут в функциональном стиле, хотя есть такие проекты.
Elixir/Erlang - работа есть, начну с этого, хотя её куда меньше чем на Scala и требования тоже не хилые.
Haskell - работы ещё меньше чем в верхних двух, надо быть реально фанатиков, что сдаться и долго искать работу.

>>981654
Cпасибо, тогда буду на scala все таки ориентироваться, да и с java знаком.

>>981656
Учти, что работа - это в любом случае хуйня, не то что свои проектики в кайф кодить. С прикладной точки зрения, разницы на чём пишешь на работе, особо и нет, потому что ты будешь и так и сяк работать 8+ часов в день, даже если решаешь задачи быстрее за счёт крутого яп. Правильнее выбирать то, на чём много вакансий и заеботые зарплаты.

>>981659
Да я вообще вкатываюсь в js, это я на будущее думаю, куда перекатываться, не очень js и фронт нравится, но это довольно просто и времени на изучение этого много не нужно + куча вакансий. Для себя начал учить haskell и понял, что хочется в будущем работать на чем-то подобном.

>>981661
>довольно просто
всмысле начать довольно просто по сравнению с java c++ и тд

>>981659
Это в превозмогающей. А в загнивающей всё помягче, можно и 6 часов, можно и 4.

>>981961
По поводу лямбда калькулуса, первые три лекции вот этого курса дают хорошее представление https://compscicenter.ru/courses/func-prog/2015-spring/?tab=classes

>>981966
Судя по отзывах, у Москвина в целом курсу по ФП и Хачкеле - лучше не бывет. Может упорюсь когда-нибудь.

спрашиваю здесь, так как ФП треда нет
Сравните плз. по хардкору F# и Scala, те, кто разбирается. Что более труЪ ФП? Делаю эпохальный для себя выбор: .NET vs JVM, но в функциональном духе. Короче, что брать?

>>981980
Да мне нравится, делаю задачки на степике, а видео смотрю с того курса, так как на степике очень сжато. Да еще есть практические задания к курсу в открытом доступе http://mit.spbau.ru/sewiki/index.php/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_2015

>>981987
тебе что больше нравится C# или Java? писать-то все равно на них будешь.

>>981992
Ты что слепой? Я ж написал - выбираю между F# и Scala. Императивщина не рассматривается.

>>981994
Он про то, что вакансий на чистых scala/F# нет, везде это идут, как доп языки. А по твоему вопросу ближе к haskell F# стоит, так как корни у языков одни - ML

>>981997
Да я не спрашивал про вакансии, я спрашивал про языки. Вы с кем там разговариваете, вообще?

>>981464
Кек

>>982008
То есть, ты намекаешь на F#?

>>981994
На работе ты не будешь писать только на F#/Scala, ты будешь писать на их смеси с C#/Java.
Если тебе не для работы, то Haskell.

>>982024
Ну ёпрст Ты говоришь о том, что и так всем очевидно. Чтобы избежать таких ответов я специально задал конкретный вопрос. По языкам-то что? Кто-нибудь знает?

>>982035
да похуйу всем
скала это солянка, но у нее есть завтипы
F# похож на окамл, более MLный, так что потом сможешь посмотреть на всякие SML, OCaml

>>982037
>завтипы
Это даже в C++ есть.

>>982037
>F# похож на окамл, более MLный, так что потом сможешь посмотреть на всякие SML, OCaml
Есть смысл после F# смотреть на OCaml?

>>982047
Если тебя ещё не заебало это всё - тогда конечно. Там гораздо больше фич, функторы, параметризуемые модули, структурный сабстайпинг и тд.

Может кто-нибудь поделиться свежей версией Haskell Programming from first principles? В интернетах нашел только версию на начало 2016 года.

>>982168
У меня есть полная, но нимагу, прости.
Самому подогнал человек, купивший её, под обещание больше никому не давать даже мамке. Более того, у меня есть подозрение, что дистрибьютор впиливает туде цифровые метки, которые могут указать на него, когда она с двачей перекатится во все торрент трекеры. А таки перекатится, потому что кроме устаревшей копии в сети ничего нет.

>>982206
Да ничего, братунь. Я уже и авторам написал, попросил скидку для российских нищебродов, но если ничего не ответят в течение 2-3 дней, то куплю видимо за полную цену.

>>982206
>>982280
А эта версия 2016 насколько сыра? Полистал - вроде нормас.
Купил бы если бы работал и были деньги.

>>982282
Пары глав в конце не хватает, плюс, насколько я понимаю, другие главы тоже допиливались с тех пор. Как куплю, сравню и отпишусь.

>>982282
Я перекатился главы где-то с седьмой, и по диагонали сравнил пройденный материал (по диагонали, потому что попробуй-ка нормально сравнить овер 200 страниц).

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

Но они есть - если сравнивать только по утекшему в сеть материалу - овер 100 страниц. Пикрилейтед.

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

>>981065
Хуле же ты второй вариант с двумя <> не транслировал?

> map filter
> свертки

>>982508
> t ^? key "collection" . nth 0 . (key "track" <> key "playlist") . (key "id" <> key "name") . _Integer
Каким образом здесь name превратится в Integer? Ладно, допустим ошибка.
let firstItem = res.collection[0];
let entity = firstItem.track || firstItem.playlist;
return entity.id || entity.name;
> > map filter
> > свертки
Для структур данных с append/concat за O(1) вполне
let map = (f, xs) => xs.reduce((a, x) => a.concat([f(x)]), []);
let filter = (p, xs) => xs.reduce((a, x) => a.concat(p(x) ? [x]: []), []);

>>982548
Справедливо.

>>969768 (OP)
Почему так

lucky :: (Integral a) => a -> String
lucky 7 = "LUCKY NUMBER SEVEN!"

а не так?

lucky :: Integral -> String
lucky 7 = "LUCKY NUMBER SEVEN!"

?

>>983816
Integral - это тайпкласс, а не тип. Нет такого типа. Есть Int и Integer. В сигнатуре то, что перед "=>" называется class constraint. В нем ты указываешь тайпклассы, к которым может принадлежать типы инпута/аутпута. А дальше, после "=>" следуют типы данных которые принимает и возвращает функция (а вообще все функции в хаскелле принимают только один аргумент). т.к. ты указал, что тип а принадлежит интеграл, то принимает эта функция число. я сам ток учу, так что могу ошибаться. поправьте если что

>>983853
всё правильно
проще говоря, тип, принимаемый ф-ей lucky, может быть любым типом, реализующим класс Integral (Int, Integer, ещё вроде какие-то специфичные есть)

>>983816
Вот этот >>983853 правильно сказал, но стоит добавить почему именно нотация выглядит именно так, почему тайпкласс нельзя вписать Integral -> String

Потому, что тайпклассов в констрейнте может быть много, например
(Bounded a, Ord a) => a -> a -> Bool

Я, конечно, капитанствую, но для совсем ньюфагом лучше лишний раз явно сказать.

>>982315
дякую анончику, приду к успеху, куплю и тогда уже буду аутировать если

>>984135
Будь ласка. Ты пока упарывай доступную версию, ты и без главы посвящённой сугубо IO закончишь материал монадическим титаном на самом деле ніт, но знаний будет достаточно, чтобы начать что-то пилить.

>>984153
>>984135
Теперь це український Haskell-тред?

>>985237
Нет, не суметь в "пожалуйста" на украинском это лингвоинвалидом надо быть.

Как за очень краткое время понять всю типизацию в хаскелле? Очень краткое

>>985461
www.cis.upenn.edu/~justhsu/docs/nokinds.pdf

>>987718
>Traversable
Да жесткая тема, попробуй по кускам разобрать определение функции traverse на простом случае типо https://ideone.com/8YjwQx

Это грубо говоря универсальный интерфейс для того, что менять местами внутренний и внешний контейнеры

>>987739
Я спутал с функцией sequenceA, traverse просто мапит функцию из какого-то значения в контейнер и упаковывает в другой контейнер при этом тип значения может быть функцией изменен

>>987739
Не, мне такое объяснение не катит.

Внешнюю сторону я чисто интуитивно разглядел, с трюками типа
traverse id [[1], [2]] = [[1,2]]
traverse id [[1, 2]] = [[1],[2]]
Еще увидел как что-то типа цепочки IO вычислений перепаковать в одну IO цепочки, выглядит удобно. Но вот только интуитивно разглядел, а понять не могу совсем.

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

А с Traversable пиздец. Чувствую себя довеном. С написанием нетривиальных инстансов тоже проблемы.

А ещё прочитал, что Traversable вкатили относительно недавно, раньше не было. Но потом кто-то решил принести больше абстракции богу абстракции, что не всем в интернетах понравилось.

Нашёл вот туториал, о котором говорят, что простой, попробую покурить.

>>987751
туториал отклеился
http://blog.jakubarnold.cz/2014/07/30/foldable-and-traversable.html

>>987751
>цепочки IO вычислений перепаковать в одну IO цепочки
Плохо выразился, довен же.
Скорее имел в виду не перепаковку, а альтернативу функтору, применив который можно получить структуру IO-результатов, а альтернатива даёт структуру результатов внутри IO а внутре неонка.

Как пользовать я разглядел, а как понять - нет.

>>987759
Ну, то есть, перепаковать вывернуть наизнанку тоже можно, протраверсив применив id, но такой способ не выглядит нужным, если можешь сразу траверсить.

>>987858
Ну ты хорош, конечно, но нам Денчик это в спец-курсе рассказывал. Кидал выше соус на степик.

>>987937
Раз я уже начал по литературе, так и продолжу.

Слабо представляю, как перекатиться на степик, бросив то, что начал штоле? А курс Москвина сначала, или с момента, куда я по литературе дошёл?
https://www.youtube.com/watch?v=S9Nkfi_NLXI

Думаю, закончу то, что есть, а там посмотрим, мне ведь ничто не мешает ещё и курс Москвина поверх накатить. Тем более, те вещи, в которых разобрался с трудом, но сам, они лучше усваиваются.
Хотя с курсом непонятно. Там же, наверное, видео-лекции, а не бумажные. Как вообще на ютюбе учиться? Я только по книжкам умею.

traverse это просто mapM
только требует аппликатив вместо монады

>>987943
>mapM

Не является функцией инстанса необходимой для определения. Я её в общем видел, но над вопросами реализации не задумывался.

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

Хотя, конечно, упростил я со списком. Foldable констрейнт в моей имплементации не нужен.
Я так понимаю, можна запилить дженерик-реализацию через фолдинг. Когда-нибудь я попробую и это говно. Наверное, завтра. Чувствую жопой что, если получится, это будет вообще эзотерический readonly код.

>>987945
>дженерик-реализацию через фолдинг. Когда-нибудь я попробую и это говно.

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

Но через foldr невозбранно запилил пикрилейтед

>>988079
А теперь проверь на соответствие monad laws. Подозреваю, где-то ты их нарушил, ибо traversable должен сохранять структуру при traverse, а monoid подразумевает свертку структуры в единичный итем.

>>988558
Не monad, а traversable laws, конечно же.

>>988558
Алсо если с английским проблем нет, рекомендую оригинальный paper по Traversable ("The Essence of the Iterator Pattern")

>>988559
Проверил с помощью QuickCheck & Checkers, конечно.

>>988558
По крайней мере соблюдается для тех моноидов, что я тестировал. Думаю, можно и разъебать. Но это не то чтобы серъезная функция, просто типоёбство, чтобы развить интуитивное понимание, в также я закрепил понимание Traversable.

>>988558
Бля, а ведь пролопоушил у тебя самую писечку.

Моноид, тащемта, определяется ассоциативной операцией на множестве, имеющем identity элемент относительно этой операции.

Свёртываемость - это к Foldable, который, кстати, необходим для Traversable.

Есть хаскелл для детей или хотя бы школьников?

>>988681
Так хаскель и есть для школньиков.
Для его изучения достаточно знаний по алгебре за 8-9 класс.

>>988717
Более того, кмк его легче учить чистым не изнасилованным ООП и императивщиной мозгом.

>>988721
Ну императивщину полностью не вычеркнуть, даже в Haskell, если речь идёт по последовательных вычислениях, юзают do-нотацию, потому что так читать проще. А вот ООП действительно засирает мозги, и люди потом не могут понять как структурировать программы другими способами, пусть даже более выразительными.

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

>>988728
Всё так, но проще читать императивный синтаксис do-нотации, чем бесконечные вложения лямбд с >>= и >>.

>>988730
Ну с таким же успехом let-нотацию и where- можно императивными назвать. Но спорить не стоит, в том, что это слегка напоминает императивный код, я согласен.

>>969781
Кинь книгу пожалуйста.

>>989215
https://gumroad.com/l/haskellbook

>>989304
Такой то шутничок. Но я нашел уже.

>>989384
Где взять?

>>990493
https://www.lumendatabase.org/notices/13247906

>>990652
как удобно!

Чо мне делать в линуксах чтоб хацкель закомпилировался? Ну установил я haskell-platform на atom. А дальше куда?

>>990798
Как поставил так и удали. Я сам наебался страшно, пока не выпилил платформу нахуй.

Поставь stack из репы, это всё, что тебе нужно. И читай как его использовать.

Скажите, какой самый лучший/правильный подход к параллелизму в ФП?

>>991004
Чистота языка

Сап, хаскач. Как начать понимать что-либо в лямда-нотациях? Можно ли сигнатуру представлять в \-виде?

>>992616
Так оно всё в таком виде. Просто сахарок повсюду.

Где почитать всякую философскую муть по функциональному программированию, его развитию, перспективах и таком духе?

>>992646
Извини за тупость и дерзость, но не мог бы ты помочь мне написать лямбда-нотации к следующим вещам или хотя бы на примере одной на пальцах объяснить принцип перевода в \-нотацию:

isPeriodic :: Library -> Bool

isPeriodic (Newspaper _ _ _ _) = True

getByMonths :: [Library] -> [Int] -> Int -> [Library]

findEq (x:xs) y = if x/=y then x:findEq xs y else x:xs

>>992730
findEq = \(x:xs) -> \y -> if x/=y then x:findEq xs y else x:xs

Сигнатуры уже в таком виде.

>>992730
В простейшем случае (a x₁ ... xₙ = b [x₁, ..., xₙ]) есть дериватная форма для абстракции (λ x₁ ... xₙ . a = b [x₁, ..., xₙ])

>>992766
вернее a определяется как абстракция:
a = λ x₁ ... xₙ . b [x₁, ..., xₙ]
(но только в случае, когда x₁ ... xₙ - переменные и других клозов нет)

>>991051
Что выбрать из par/pseq, evaluate strategies, Par-monad, MVar, LVish? Что каноничнее?

>>993711
Судя по всему, ты путаешь parallelism и concurrency. Разберись для начала с этим, а дальше просто бери repa или accelerate.

>>993817
Ничего я не путаю. Мне нужен именно параллелизм. Все перечисленные подходы относятся к параллелизму в хаскеле.

>>993879
Особенно MVar, ага.

Функциональный, разъясни пазязя почему этот код:

foldl (\x acc -> if (length x > length acc) then x else acc ) [] [[1],[2]]

выводит:
[2]

Должно же [1] выводиться.

http://rextester.com/EXN32250

А, не, туплю, посмотрел доку еще раз - все правильно.

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

data Person = Person { fisrtName :: String }

Main> :l test.hs
Main> :t firstName
firstName :: Person -> String

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

Бамп

>>981961
Блэт
гдэ бы столько времени взять чтобы книги годные прочесть. Сейчас дочитываю Learn you haskell for great good

>>995663
Потому что именно для этого и был придуман параметризованный тип, блядь.
data Person = Person String
если тебе не нужна функция, блядь.

>>995819
все понятно, спасибо

а что если так

data Person = Person String String String Int String Float
data Dog = Dog String String String String

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

>>995822
Для этого есть type

>>995822
>>995826
И newtype

>>995828
Благодарю

>>995848
Для именования полей обычно используют type.
newtype немного для других целей.

>>995856
Ну не для именования полей, а переименования типа.

>>995857
Да, как раз прочитал уже что type - создает алиас для существующих типов

data Person = Person PersonName PersonAge
type PersonAge = Int
type PersonName = String

>>995663
Для этого есть классы типов:

class FirsNameable a where getFirstName :: a -> String

newtype Person = Person String
-- или data Person = Person String

instance FirsNameable Person where getFirstName (Person x) = x

main = print $ getFirstName $ Person "Huirandomniy"

>>996495
Ну, или если хочется совсем красиво, то в итоге получится вот такой легкочитаемый, легкорасширяемый и легкодополняемый ad-hoc-полиморфный код c экзистенциальными типами:

{-# LANGUAGE ExistentialQuantification #-}

class FirstNameable' a where getFirstName :: a -> FirstName

type FirstName = String
type Age = Double
newtype Person = Person {getPersonFirstName :: FirstName}
data Seld' = Seld' {getSeld'FirstName :: FirstName, getSeld'Age :: Age}
data FirstNameable = forall a . FirstNameable' a => FirstNameable a

firstName (FirstNameable x) = getFirstName x

instance FirstNameable' Person where getFirstName = getPersonFirstName

instance FirstNameable' Seld' where getFirstName = getSeld'FirstName

gospodin = Person "Huirandomniy"
gospozha = Seld' "Pelotka" 40

main = mapM_ (print . firstName) [FirstNameable gospodin, FirstNameable gospozha]

>>969768 (OP)
Работаю с хаскелем, если есть вопросым задавайте.

>>997037
Как и за сколько времени освоился с всякими функторами, монадами и прочего из теории категорий?

какое отношение у хаскелистов к idris?
думаю вкатиться со скалы в хаскель или идрис
я правильно понимаю что идрис = хаскель + зав типы?
можно ли сразу начинать с идриса?

>>997037
насколько щедро плотют?

>>997051
В общих чертах ознакомился с языком, посмотрел пару примеров на гитхабе, сделал кой чего сам и все. Работаю и продолжаю изучать.
Взяли как раз из-за того что мало спецов на рынке.
>>997054
На житье-бытье хватает.

>>997175
какой город?

>>997179
NY

>>997205
замечал кстати что на хаскеле внезапно много перекатных вакансий в сша

>>997175
а до этого какой опыт? сеньор помидор 10 лет опыта опердней на эрланге?

>>997355
До этого админом работал и software developer С++

>>997037
безумно рад за тебя анон

>>969768 (OP)
неужели есть реальные вакансии на хаскел дев в 2017? Может еще и аутсорс?

>>981987
Нормальное ФП только в Хаскелле (из живых языков). Но если выбирать из F# и Скалы, я бы выбрал Скалу. F# сильно косит под ФП, поскольку спиздил синтаксис из Окамла, но по сути проект проприетарный с полудохлым комьюнити. Я не знаю на F# каких-нибудь продуктов уровня Спарка или Кафки, я вообще не знаю, нахуй F# нужен. Ну разве что какую-нибудь хуитку писать, убедив начальника, что C# - это не тру, а F# - тру, хотя разница между ними весьма небольшая (не такая, как между Скалой и Джавой, поэтому не представляю какие аргументы ты сможешь привести).

Скала, конечно, сделана с большим упором на ООП, но там более серьезная система типов, чем в F#, а вообще нормальная система типов - это одна из главных фич, ради которой ФП существует в принципе. На ней пилятся серьезные проекты, в которые вкладывается дофига бабла, на ней проще найти хорошую работу. Там в комьюнити полно настоящих ФП-шников, которые пришли туда из Хаскеля, с корорыми есть о чем поговорить и у которых есть чему поучиться.

https://haskellweekly.news

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

Похоже, этот цикл никогда не закончится.
На этот раз я застопорился на cmap.
forall a b. (b -> a) -> f a -> f b
Как это добро использовать? Откуда я знаю, какой функцией получить a из b?

>>1000698

newtype Predicate a = Predicate (a -> Bool)
instance Contravariant Predicate where
cmap f (Predicate g) = g . f

>>1000762
Точно же! Маппинг работает для значений, контрмаппинг работает для стрелок. Как все просто.

>Я не знаю на F# каких-нибудь продуктов уровня Спарка или Кафки

то что ты их не знаешь не означает что их не существует
https://blogs.msdn.microsoft.com/dotnet/2016/12/13/project-springfield-a-cloud-service-built-entirely-in-f/

jet.com алсо гугли

http://fsharp.org/testimonials/ забыл

>>1003388
Ты пару слов пропустил:
>того же уровня

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

>>994521
x и acc местами поменяй

У нас были

data Item = Item { value :: Int, weight :: Int } deriving (Eq, Show)
data Problem = Knapsack Int [Item] deriving (Eq, Show)
data Solution = KnapsackSolution Int [Item] deriving (Eq, Show)

и решение задачи о рюкзаке с набором без ограничений в виде

dpKnapsackUB :: Problem -> Int
dpKnapsackUB (Knapsack capacity items) = trace (show table) (table ! capacity) where
table = array (0, capacity) [(w, opt w) | w <- [0..capacity]]
opt 0 = 0
opt w = maximum $ 0:[value i + table ! (w - weight i) | i <- items, weight i <= w]

Не то чтобы это было нормальное решение, но когда решил ещё возвращать список элементов попавших в рюкзак, становится трудно остановиться. Единственное, что вызывало у меня опасение - это монады и Trace / State / whatever. Я знал, что рано или поздно мы перейдем и на эту дрянь.

Анон, подскажи, у меня есть шанс отрефакторить функцию в
dpKnapsackUB' :: Problem -> Solution?

Кто читал книгу Холомьева?
https://anton-k.github.io/ru-haskell-book/book/5.html#упражнения
Упражнение в пятой главе.

Рассмотрим такой тип:

data St a b = St (a -> (b, St a b))

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

ap :: St a b -> [a] ->

Она принимает ленту входящих значений и возвращает ленту выходов.

Что тут надо сделать? Вроде речь про потоки, которые мы сами до этого делали, но тут ap принимает и выдает просто списки. Ну да ладно, они могут быть бесконечными. Я вроде сделал ap и функцию изменеия списков для теста, которая берет поток и прибавляет 1 к каждому значения в новом потоке.

ap::St a b -> [a] ->
ap (St f) (x:xs) = fst (f x) : ap (St f) xs

myf::Int -> (Int, St Int Int)
myf a = (a + 1, St myf)

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

Блять, хуле же так сложно то с этой вашей теорией категорий. Пытаюсь высрать реализацию Foldable для двоичного дерева. Мозги скрипят, пиздец.

>>1007487
Ты почти постиг дзен. Теперь осталось ответить на один простой вопрос - зачем? Зачем все это? Как это приближает тебя к решению конкретной задачи?

>>1007487
>реализацию Foldable для двоичного дерева
А как ты для этого используешь теорию категорий?

>>1007543
Упражнение в книжке. Приближает к возможности практического применения инструмента.
>>1007547
Никак. Просто пришел на двачи поныть о том что сложна.

Что скажете за purescript? Кто пользовался для реальных проектов?

Обязательно ли знать наизусть все моноиды, функторы, и прочее для того чтобы писать продакшн код?

>>1004491

>Единственное, что вызывало у меня опасение - это монады

А зря. Кто умеет в монады, тот длинные list comprehensions в одну строку не пишет.

>Анон, подскажи, у меня есть шанс отрефакторить функцию в
>dpKnapsackUB' :: Problem -> Solution?

Внезапно да. Например вот так:

--import Control.Monad (guard)

data Item = Item { value :: Int, weight :: Int } deriving (Eq, Ord, Show)
data Problem = Knapsack Int [Item] deriving (Eq, Show)
data Solution = KnapsackSolution Int [Item] deriving (Eq, Ord, Show)

dpKnapsackUB' :: Problem -> Solution
dpKnapsackUB' (Knapsack capacity items) = table ! capacity
  where table = array (0, capacity) [(w, opt w) | w <- [0..capacity]]
        empty = KnapsackSolution 0 []
        opt 0 = empty
        opt w = maximum . (empty :) $ do
            --i <- items
            --guard $ weight i <= w
            i <- filter ((<= w) . weight) items
            let KnapsackSolution optVal optItems = table ! (w - weight i)
            return $ KnapsackSolution (value i + optVal) (i : optItems)

Выведенный Ord на типах позволяет не писать maximumBy с разбором кортежей или похожую хуйню. Про guard можешь прочитать в доках к Control.Monad. Я сначала написал с ним, но потом подумал, что лучше не добавлять лишних модулей просто так.

>>1007175

>Но нахуя эту функцию оборачивать в St a b
Чтоб задать тип, в котором он же сам и используется, очевидно же.

>а возврат самой себя нафиг не нужен
Тащемта нужен. Тебе там предлагают написать integral :: Num a => St a a, который выдаёт "ленту" частичных сумм. А для этого надо помнить предыдущую частичную сумму, ведь к ней надо будет прибавлять текущий элемент. Так вот, для этого функция внутри St должна уметь изменять не только свой аргумент, но и саму себя. Именно новую версию самой себя, которую надо будет применить к следующему элементу, она и возвращает вторым элементом кортежа, который ты выкидываешь.

Функцию f :: St a b, которой не нужно себя изменять (применяемую поэлементно, подобно map g :: [a] -> для списков) при этом можно будет получить как f = lift f' для некоторой f' :: a -> b. Попробуй написать lift :: (a -> b) -> St a b, который это делает — с ним можно будет "поднимать" обычные функции до функций над потоками, легко написать const :: a -> St b a и проверить тот же ap :: St a b -> [a] -> на конкретных примерах.

>>1008188

>>map g :: [a] ->
map g :: [a] -> [b]

>>ap :: St a b -> [a] ->
ap :: St a b -> [a] -> [b]

Макаба съела [b].

>>1008188
Вот спасибо, кажется начинаю понимать.
Но жаль что сам не мог допереть до понимния. Или все таки слишком недостаточное описание в упражнениях.

>>1008190
Охуеваю с вашего кода.

мимопроходил

>>1008439
В данном случае это не код, а аннотация типа.

>>1008297
Хорошие задачки. Тоже изучаю хаскель. Давай делиться решениями тут. Мое на ideone:

http://ideone.com/ivPNU3

>>1008702
Игрался с потоками и придумал еще одну задачку. Написать функцию взятия производной от потока, такую, что

derivative :: Num a => St a a

(derivative . integral) == (integral . derivative)

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

>>1008702
В принципе у меня примерно так же получилось, только конструкции не такие локаничные, я нуб.
За исключением id в инстансе для Category St. Я не врубаюсь в него никак и не могу понять почему он реализуется так в данном случае (я сделал что-то другое и оно не работает как надо). Кажется, что все просто, он просто берет что-то и возвращается то же самое. В данном случае это экземпляр для St и он должен принимать St, хотя он не принимает никаких аргументов, а является константой, это я тоже не очень четко понимаю.

В твоих тестах следующее
ap (integral . id) [0,1,2]
Как оно работает? Ведь в ap эта композиция принимает элементы листа? То есть сначала берется 0 и к нему применяется id, который должен брать/быть что-то типа St, то есть функцию.

>>1008830
Я так начинаю понимать, что id сам является функцией типа St, которая работает как обычный id для элементов листа.
А если применить id к чему-то с типом St, то что будет. Или оно так не должно применяться..

>>1008830
>и он должен принимать St
Сам по себе он ничего не принимает (элементы в него суёт ap), он является как бы "обёрткой", для которой ты можешь определять классы типов. Когда нужна функция - "распаковываешь" (сопоставлением по образцу) и работаешь с ней. Для таких случаев ещё newtype есть и record syntax, чтобы "распаковывать" можно было и специальной функцией, и образцами. Например:

newtype St a b = St { getSt :: a -> (b, St a b) }

getSt "распаковывает", St "запаковывает". В стандартной библиотеке есть несколько примеров вроде ZipList из Control.Applicative. Это "обёртка" над списком, которая позволяет задать ещё одну реализацию класса Applicative, не конфликтуя с реализацией Applicative из Prelude.

>Как оно работает?
Если ты про (.), то там та же идея, что и для функций, только с учётом второго элемента (новой St, которую надо применять к следующему элементу). Текущий пропускается сначала через (распакованную) g, потом через (распакованную) f, а в качестве новой St для результата композиции будет взята (наша) композиция новой St для f (обозначенной через f1) и новой St для g (обозначенной через g1).

>>1008837
>А если применить id к чему-то с типом St, то что будет. Или оно так не должно применяться..
То же самое и будет, к чему применил. id задан в классе типов, т.е. реализация его выбирается в зависимости от требуемого типа. Ты его применяешь => тебе нужна функция => выбирается реализация для функций. Если не импортировать Control.Category, то будет id из Prelude, который всегда является функцией.

>>1008786
Хорошая задачка, даже Applicative пригодился.


derivative :: Num a => St a a
derivative = f 0
    --where f n = St $ \x -> (x - n, f x)
    where f n = St $ (,) <$> subtract n <*> f

>>1008830
>это я тоже не очень четко понимаю.

Я не понимаю с точки зрения теории категорий. С ней знаком поверхностно. С этой точки зрения St образует категорию, в которой объектами являются еще и сами морфизмы, но возможно ли такое - не знаю.

Мое глупое понимание сводится к "коробочкам". St - это конверт с инструкцией, в которой указано что надо сделать с исходным объектом, чтобы получить новый объект и новую инструкцию для работы со следующим объектом. Т.к. St является конвертом, значит напрямую он не может ничего делать. Поэтому нужен внешний исполнитель, коим и является ap, умеющий читать инструкции.

id с этой точки зрения работает так. В инструкции написано: верни сам объект, в следующий раз используй эту же инструкцию. Исполнитель ap это и делает.

>Как оно работает? Ведь в ap эта композиция принимает элементы листа?

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

>>1008943
Так же получилось, как в закомментированной строчке.

Как написать quicksort на хаскеле таким же быстрым, как на C или C++?

>>1009970
Главное препятствие - runtime system, реализующая семантику аппликативных вычислений на тьюринг-архитектуре.
Самый разумный способ - взять C/C++
вместо хаскеля.

>>1009987
Изменяемые данные (без создания копии) в хаскеле никак невозможны?
мимобайтоеб

>>1010005
На анбоксед векторах разве что

>>1009970
http://hackage.haskell.org/package/vector-algorithms-0.7.0.1/docs/src/Data-Vector-Algorithms-Merge.html#sort

>>987751
Тоже нихуя не понятно.
> :t traverse
traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
> :t id
id :: a -> a
И внезапно
>:t traverse id
traverse id :: (Traversable t, Applicative f) => t (f b) -> f (t b)

Как id можно запихать в traverse, оно же по типу не подходит?

>>1010348
a и f b это тот самый тип

>>1010348
Стоило только спросить на двачах, как сразу снизошло озарение, лол. Если a :: f b

>>1010349
Один и тот же в смысле

>>1010353

Спросим, нафиг тебе функция, принимающая Traversable и ни на что не влияющий аргумент и заменяющая каждый элемент на const "shit". Или это пример, когда у тебя в итоге получается (Traversable t, Applicative f) => t (f a), на котором сработает traverse id?

Как в purescript-free-canvas выполнять произвольные действия?

>>1010683
Что такое "произвольные действия"?

>>1011733
Наверное он имеет ввиду побочные эффекты.

>>1012598
Думаю он имел ввиду https://github.com/paf31/purescript-free-canvas/issues/1
Но я по прежнему не понимаю что за "arbitrary actions".

Реквестирую годный туториал про monad transformers

Как дебажить хачкель?

>>1016917
GHCI и Debug.Trace

>>1016918
А можно пример для ленивых?

>>1016922
https://downloads.haskell.org/~ghc/8.0.2/docs/html/users_guide/ghci.html#the-ghci-debugger

Недавно имел незащищенный контакт с вебдевелопоментом в редукасе-реакте. Теперь хочу функционироваться. Стоит ли изучать Кашель? Кто использует в продакшене? Что есть в Кашеле чего нет в Йобаскрипте2015-2017?

>>1016976
Встань на истинно верный путь: http://www.purescript.org/

Что такое монады и системы эффектов и чем они отличаются?

>>1016976
>Кто использует в продакшене?
Standard Chartered
Standard & Poor's
J.P. Morgan
Facebook
Target

Есть какой-то MOOC пол алгоритмам/структурам данных на *ML-языке, но я проебал ссылку, поделитесь.

>>1017066
Монада - это моноид в категории эндофункторов. Системы эффектов - вычислители, производящие неявную работу, связанную с изменением окружения.

насколько нужен матан чтобы писать на Хачике?

>>1018516
насколько нужен хачик, чтобы писать на матане?

>>1018516
Нинужен совсем. Даже теоркат не нужен.

>>1018516
Чот мне кажется, что Idris попроще хаскелла в плане необходимого матана.

>>1018516
Если говорить сугубо языке программирования, то никакое знание математики кроме разве школьного для хаскеля не нужно.
Математику (не мат анализ наверное имеется ввиду?) в принципе неплохо понимать чтобы писать хорошие алгоритмы, с другой стороны если голова на месте, то можно интуитивно понять что алгоритм не оптимален, иногда он очевидно не оптимален. Но тут на мой взгляд достаточно просто в теорию алгоритмов окунуться.

Есть один вопрос по Idris, думаю ничего если задам его здесь.
Когда я пытаюсь выполнить
sum [1..1000]
отедается гиг памяти в все зависает. На сколько это ожидаемое поведение? 1.0 под windows.

>>1021705
> The REPL uses recursively defined peano nats

>>1021713
> peano nuts

>>1021705
Посчитай как-то так: 1000(1000+1)/2

У меня есть стейт для галлерии. Индекс текущей пикчи и общее кол-во.
Нужно написать две функции, которые будут это дело инкрементить.
Что-то умнее
> if x + 1 > total then shit else fuck
можно придумать?

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

>>980926
У скалы охуенный синтаксис, бич. Когда пердолил Сикп и ебался с лиспом чувствовал, что мне нужно что-то вроде скалы

>>1021977
>Что-то умнее
Завернуть всё в альтернативный функтор и получится что-то типа:
nextIndex <*> shit <|> fuck

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

сравни:
justPlus x y = pure (+) <> x <> y
или
justPlus' = liftA2 (+)

С этим:

justPlus'' (Just x) (Just y) = Just (x + y)
justPlus'' _ _ = Nothing

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

>>1024778
Я все понимаю на уровне тупорылых примеров типа Just 2 + Just 3
Мне не понятно практическое применение этого.
Почему я должен захотеть использовать это вместо do нотации с монадами, например.

>>1024818
Нету причин. Монады строго мощнее аппликативных функторов

>>1024827
Но я почему то вижу дохуя апи построенных на них. НИПОНЯТНО.

>>1024862
значит для апи достаточно только аппликативных функторов же

>>1024910
http://purescript-pux.org/docs/routing/
Вот чому они тут сделали через сфинктеры, а не через монадки? Как бы это вообще сделать через монадки?

>>1024911
PageView $ fromMaybe NotFound $ router url $
(do
end
pure Home)
`mplus`
(do
lit "users"
s <- param "sortBy"
end
pure $ Users s)
`mplus`
(do
lit "users"
end
pure $ Users "name")
`mplus`
(do
lit "users"
i <- int
end
pure $ User i)

>>1024923
Вай-вай, что ты делаешь, прекрати. Скобки же не завезли. Залей куда-нибудь, будь человеком.

>>1024818
>>1024862
Не всякий аппликативный функтор может стать монадой. Попробуй полифть в монаду вот такую функцию f :: a -> a -> a

Из аппликативных функторов легко можно составить композицию, из монад - нетда, Monad transformers.

>>1024930
Можешь пояснить на пальцах, что такое free monad?

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

>>1025356
Юз кейсы?

Скажем я прекрасно владею рекурсией, понимаю когда можно использовать фолды и даже всякие foldM.
Более менее понятно когда нужны монады.

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

>>1025401
>Но я немножко не догоняю кто же все таки запускает вычисления.
Если говорить про IO, то вычисления "запускает" рантайм GHC.
В остальных случаях по разному. Если например монада - список, то на выходе и получается список, а дальше делай с ним что хочешь.
Разберись для начала с монадами, потом с трансформерами, а дальше Free на ура пойдет

>>1025407
Да я вроде все понимаю на уровне теории. Понимаю как пользоваться библиотекой, которая построена на монадах. А когда дело доходит до практики, то не возникает желания "А въебу ка я тут монаду".

Трансформеры тоже не очень не понимаю. Я же могу смешивать в одной цепочки do скажем Maybe и log. Но log идет как бы сбоку в виде сайд эффекта. Получается трансформеры нужны чтобы сделать Maybe + Reader например?

Реквестирую видосов по теории категорий.

>>1025421
даже не думай

>>1025425
Чому?

>>1025421
В общем подсел на усатика: https://www.youtube.com/watch?v=I8LbkfSSR58

>>1025417
>не возникает желания "А въебу ка я тут монаду"
Да тут просто надо смотреть на задачу. Есть цепочка однотипных вычислений - юзай анфолд-фолд. Есть у этих вычислений побочные эффекты, порядок которых важен - юзай аппликативный функтор. Важен и порядок вычислений, и эффектов - заверни в монаду.

>Я же могу смешивать в одной цепочки do скажем Maybe и log
Можешь смешивать любые монады и без монадных трансформеров. Но при этом тебе придется вручную комбинировать-разбирать их, а bind сделает это за тебя.

Ньюфаг ИТТ. ЧЯДНТ?
data Single_Multiple a = Multiple Int a | Single a deriving (Eq, Show)
mod_length_enc :: (Eq a) => [a] -> [Single_Multiple a]
mod_length_enc xs = [ \(x,y) -> if x==1 then Single y else Multiple x y | (x ,y) <- Lists1.length_enc xs]
Lists1.length_enc возвращает список пар (1, "a")(2, "b") и т.д.
Ошибка:
• Couldn't match expected type ‘Single_Multiple a’
with actual type ‘(Int, a0) -> Single_Multiple a0’
• The lambda expression ‘\ (x, y) -> ...’ has one argument,
but its type ‘Single_Multiple a’ has none

Притом, если сделать так:
mod_length_enc xs = [ f | (x,y) <- Lists1.length_enc xs, let f = if x==1 then Single y else Multiple x y]
то все работает. Почему?

>>1035152
> \(x,y) -> if x==1 then Single y else Multiple x y
Это имеет тип (Int, a) -> Single_Multiple a

> f
Это имеет тип Single_Multiple a, это не функция

Поясните за continuations на пальцах. С меня нихуя.

>>1035424
Вроде дошло, спасибо. Тупанул. Лямбда только определяет, а не вызывает функцию. Получается, let - это что-то типа макроса в C?

Покажите, кто-нибудь, как в хаскеле выглядят замыкания.
Все вокруг твердят, что замыкания относятся к ФП, но я их никогда не встречал в хаскеле. Из ФП знаю только хаскель

>>1036815
Да так же как и везде. Замыкания просто напросто дают доступ к лексической (читай визуально видимой) обласит видимости.
http://paste.org.ru/?fxi7za
Лямбда которая возвращается из функции tag умеет пользоваться переменными open и close из своего замыкания.

>>1036829
А в чём 'глубокий смысл' таких 'замыканий'?

>>1036829
Никогда бы не подумал, что where или let -конструкции кто-то называет замыканиями.
Смысл замыканий, насколько я это понимаю, совсем не в этом.

>>1024462
>ебался с лиспом
Сейчас бы с лиспом ебаться, он прост как дважды два.

>>1036867
В том что тебе не нужно пихать аргументы во вложенные вспомогательные функции. Или как в примере создавать частично готовые функции.
> Замыкание (англ. closure) в программировании — функция первого класса, в теле которой присутствуют ссылки на переменные, объявленные вне тела этой функции в окружающем коде и не являющиеся её параметрами. Говоря другим языком, замыкание — функция, которая ссылается на свободные переменные в своём контексте.

>>1036894
Замыкание это лямбда, которая возвращается. А where или let позволяют этой лямбде стать замыканием.

>>1036906
Но в хаскеле переменные не объявляются (а значит, не могут быть вне функции), и ни на что не ссылаются. Все переменные - это и есть только лишь параметры функций.
Замыкание призвано решить проблему фунарга -
захвата переменных в языках, где переменная ссылается на ячейку памяти (время существования которой может не соответствовать времени вызова функции/процедуры) и аргументы передаются через стек. То есть, замыкания имеют смысл в императивном программировании. Я не понимаю, какой смысл замыкания могут иметь в ФП объясните, плз
То, что у тебя - это просто вложенные определения функций.

>>977793
emacs

>>1008143
Аноны, что за хуйня на пике? Похоже на хачкель, но как-то всё императивно слишком. И если хаскель, то нахуй писать на нём так?