Есть ли какая-нибудь интуиция, чтобы понять, как объединить две функции в Monad?

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

Я бы сказал, что использование системы типов - отличный способ развить особую интуицию. Тип join:

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

Специализированный для (->) r, он становится:

(r -> (r -> a)) -> (r -> a)

Теперь попробуем определить join для функций:

-- join :: (r -> (r -> a)) -> (r -> a)
join f = -- etc.

Мы знаем, что результатом должна быть r -> a функция:

join f = \x -> -- etc.

Однако мы вообще ничего не знаем о типах r и a, и поэтому мы ничего не знаем конкретно о f :: r -> (r -> a) и x :: r. Наше незнание означает, что мы можем сделать с ними буквально одно: передать x в качестве аргумента как f, так и f x:

join f = \x -> f x x

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

join . fmap join = join . join
join . fmap return = id
join . return = id

Проверка этого может быть еще одним приятным упражнением.

Продолжая традиционную аналогию монады как контекста для вычислений, join представляет собой метод объединения контекстов. Начнем с вашего примера. join (+) 7. Использование функции в качестве монады подразумевает монаду читателя. (+ 1) - это монада чтения, которая берет среду и добавляет к ней единицу. Таким образом, (+) будет монадой чтения внутри монады чтения. Внешняя монада чтения принимает среду n и возвращает средство чтения формы (n +), которое примет новую среду. join просто объединяет две среды, так что вы предоставляете ее один раз, и она применяет данный параметр дважды. join (+) === \x -> (+) x x.

А теперь, в общем, давайте рассмотрим еще несколько примеров. Монада Maybe представляет потенциальную неудачу. Значение Nothing - это неудачное вычисление, а Just x - успешное. Maybe в Maybe - это вычисление, которое могло дважды дать сбой. Очевидно, что значение Just (Just x) является успешным, поэтому при объединении получается Just x. Nothing или Just Nothing указывает на сбой в какой-то момент, поэтому присоединение к возможной ошибке должно указывать на сбой вычисления, то есть Nothing.

Аналогичная аналогия может быть сделана для монады списка, для которой join просто concat, монады записи, которая использует моноидальный оператор <> для объединения рассматриваемых выходных значений, или любой другой монады.

join является фундаментальным свойством монад и является операцией, которая делает его значительно сильнее, чем функтор или аппликативный функтор. Функторы можно отображать, аппликативы могут быть последовательностями, монады можно комбинировать. Категорически монада часто определяется как join и return. Так уж получилось, что в Haskell нам удобнее определять его в терминах return, (>>=) и fmap, но эти два определения оказались синонимичными.

Интуиция по поводу join такова, что это сжимает 2 контейнера в один. .например

join [[1]] => [1]
join (Just (Just 1)) => 1
join (a christmas tree decorated with small cristmas tree) => a cristmas tree

и т.д ...

Теперь, как вы можете присоединиться к функциям? Фактически функции можно рассматривать как контейнер. Если вы посмотрите, например, на хеш-таблицу. Вы даете ключ и получаете значение (или нет). Это функция key -> value (или, если хотите, key -> Maybe value). Итак, как бы вы присоединились к 2 HashMap?

Скажем, у меня есть (в стиле Python) h={"a": {"a": 1, "b": 2}, "b" : {"a" : 10, "b" : 20 }}, как я могу присоединиться к нему, или, если вы предпочитаете, сгладить его? Учитывая "a", какое значение я должен получить? h["a"] дает мне {"a":1, "b":2}. Единственное, что я могу с этим сделать, - это снова найти "a" в этом новом значении, что дает мне 1. Следовательно, join h равно {"a":1, "b":20}.

То же самое и с функцией.