Glasgow Haskell Compiler 9.12.1

https://wikireality.ru/wiki/Файл:Grossingeneur.jpg

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

А вброс-то хороший. Все кинулись объяснять соревноваться.

Товарищ писал на нём инструментарий проектирования камней в рамках стартапа. Насколько я знаю, успешно.

Монада — это моноид

Моноид — полугруппа с единицей

А вот теперь мне стало интересно. Что является единицей для монады IO? И что является умножением для монады Maybe?

Единица у всех монад это identity функция.

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

Можно представить моноид на множестве функций с операцией композиции в качестве умножения. Для него действительно единицей будет identity. Но, например, монада Maybe никак не представима в виде такого моноида.

Единица для любой монады — return (или pure, т.к. любая монада является аппликативом)

Единица она потому, что ничего не делает, кроме как оборачивает значение:

data MyMaybe a = MyJust a | MyNothing deriving Functor

instance Applicative MyMaybe where
  pure = MyJust
  MyNothing <*> _ = MyNothing
  _ <*> MyNothing = MyNothing
  MyJust f <*> MyJust x = MyJust $ f x

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

Вот тут есть довольно хорошее объяснение для Scala: https://rockthejvm.com/articles/a-monad-is-a-monoid-in-the-category-of-endofunctors-scala (открывать через VPN).

tl;dr!

Так-то можно в 2 словах сказать. У монады есть нейтральный элемент return (он же pure) и бинарная операция композиции (>=>).

return :: Monad m => a -> m a
>=> :: Monad m => (b -> m c) -> (a -> m b) -> (a -> m c)

Но в Хаскеле методом инстанса вместо (>=>) является (>>=):

>>= :: Monad m => m a -> (a -> m b) -> m b

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

ИТОГО можно составить следующую иерархию вычислений в контексте

Functor — меняет значения, но не меняет структуру (например, fmap, примененный к списку, возвращает список той же длины)

Applicative — может менять и значения, и структуру по каким-то жестким правилам, не зависящим от того, что он меняет

Monad — может менять что хочет, как хочет (т.к. (>>=) вынимает значение из монады)

return и join, как и везде.

https://christoph-horst.github.io/blog/posts/whats-the-problem.html

Но монада списка чисел определена на множестве чисел.

Вот тут ошибка. Категория — это множество и стрелки. Вот монады — это стрелки.

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

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

А вот дальше из сухой теории мы должны спуститься к монаде MayBe, Apllicative и всему тому прочему. Про это мне попадалось наиболее понятное описание у Брагилевского (Vitaly Bragilevsky, Haskell in depth, Manning, 2021) и в известном сетевом учебнике «О Хаскеле по человечески».

До меня уже дошло. Я про >=> не подумал.

множеством тут является набор стрелок

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

Мне проще представлять, что монада контейнер (список, Maybe, IO, …) элементов (чисел, строк, списков, объектов, …), а не отображение одних функций, делающих из элемента контейнер, в другие такие функции.

До меня уже дошло. Я про >=> не подумал.

(>=>) тут вообще не причём. Ассоциативной операцией является natural transformation M x M -> M, то есть join.

А вот дальше из сухой теории мы должны спуститься к монаде MayBe, Apllicative и всему тому прочему. Про это мне попадалось наиболее понятное описание у Брагилевского (Vitaly Bragilevsky, Haskell in depth, Manning, 2021) и в известном сетевом учебнике «О Хаскеле по человечески».

Кстати, об авторе. Хотя не столько о нём, сколько о его творчестве.

Наверное самое разумное объяснение монад для «среднего программиста» которое я видел это его видео которое называется «Монады - не приговор», https://www.youtube.com/watch?v=IkXg_mjNgG4 ( Bad_ptr, и никакого бурито, зацени :) )

Вообще, Monad m => a -> m b — это не монада, собственно, а стрелка Клейсли (у неё тоже есть композиция, как раз (>=>) и (<=<)), но кого это волнует. А так слушай hateyoufeel, он, наверное, больше прав.

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

natural transformation

естественное преобразование же, не?

Вот! Сбой тут возникает примерно у всех. Обратите внимание на язык FP, описанный у Филда и Харрисона (Филд, А.; Харрисон, П.: Функциональное программирование, М. Мир. 1993, pdf в сети можно найти). Язык вообще лишен свободных переменных и работает «чисто с комбинаторами». Комбинатор — это как раз пример Applicative, KMK. См. Известный Y-комбинатор рекурсии — Y f = f (Y f).

Про комбинаторы надо читать у Хаскеля (на сей раз у человека) Карри :) Он их и переоткрыл. История появления мысли о комбинаторах забавна и трагична одновременно, но это другая история.

яхз, у меня русскоязычная терминология этой области в голове напрочь отсутствует, а в словарь лезть лень (:

Практическое применение монатки, например, такое. Есть у тебя вычисление, которое может давать ошибку. Можно представить его типом Either String Result, где в строке будем хранить сообщение об ошибке. Потом, например, у тебя есть функция generateData:

loadData :: Int -> Either String Result
loadData n = if n < 0 then Left "Error" else result

Потом у тебя есть функция processData:

processData :: Result -> Either String Result
processData data = if dataGood then Right (process data) else Left "Data is not good"

Как теперь получить функцию Int -> Either String Result, которая сгенерирует данные и запустит process, если ошибок нет? А вот так: f n = loadData n >>= processData.

Вот тебе пример использования монатки

Или ещё одно (полу)практическое применение: сделать list comprehension в do-нотации

import Control.Monad

f :: (Ord a, Num a) => [a] -> [a]
f xs = do
  x <- xs
  guard (x > 0)
  pure $ 2 * x

f [-1, -2, 4] == [8]