Оператор связывания монады (›› =) ближе к композиции (объединению в цепочку) или применению функции?

Ясно, что >>= не является способом представления композиции функций. Композиция функций просто выполняется с помощью .. Однако я не думаю, что ни одна из прочитанных вами статей имела в виду это.

Они имели в виду модернизировать композицию функций для работы непосредственно с монадическими функциями, то есть функциями формы a -> m b. Технический термин для таких функций - стрелки Клейсли, и действительно, они могут состоять из <=< или >=>. (В качестве альтернативы вы можете использовать экземпляр Category, тогда вы также можете составить их с помощью . или >>>.)

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

q = h . g . f

вы можете написать

q = (\x -> (\y -> (\z -> h z) (g y)) (f x))

... конечно, предпочтительным стилем будет ^{_{(это всего лишь синтаксический сахар для лямбда-абстракции!)}}

q x = let y = f x
          z = g y
      in h z

Обратите внимание, как в лямбда-выражении композиция была заменена приложением:

q = \x -> (\y -> (\z -> h z) $ g y) $ f x

Адаптировано к стрелкам Клейсли, это означает вместо

q = h <=< g <=< f

ты пишешь

q = \x -> (\y -> (\z -> h z) =<< g y) =<< f x

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

q x = do y <- f x
         z <- g y
         h z

Итак, действительно, =<< для <=<, как $ для .. Причина, по которой все еще имеет смысл называть его оператором композиции, заключается в том, что, помимо применения к значениям, оператор >>= также выполняет нетривиальную часть композиции стрелок Клейсли, в которой композиция функций не нуждается: соединение монадических слоев.

_{Причина, по которой это работает, заключается в том, что Hask является декартовой закрытой категорией, в частности, четко обозначенной категории. В такой категории стрелки могут, в широком смысле, определяться набором всех их результатов при применении к простым значениям аргументов.}

_{@adamse отмечает, что let на самом деле не является синтаксическим сахаром для лямбда-абстракции. Это особенно актуально в случае рекурсивных определений, которые нельзя напрямую записать с помощью лямбда. Но в таких простых случаях, как здесь, let действительно ведет себя как синтаксический сахар для лямбда-выражений, точно так же, как do нотация является синтаксическим сахаром для лямбда-выражений и >>=. (Кстати, есть расширение, которое позволяет рекурсию даже в do нотации ... оно обходит лямбда-ограничение с помощью комбинаторов с фиксированной точкой .)}

Рассмотрим это в качестве иллюстрации:

($)                ::   (a -> b) ->   a ->   b
let g=g in (g  $)  ::                 a ->   b
            g      ::   (a -> b)
                                     _____
Functor f =>                        /     \
(<$>)              ::   (a -> b) -> f a -> f b
let g=g in (g <$>) ::               f a -> f b
            g      ::   (a -> b) 
                       ___________________
Applicative f =>      /             /     \
(<*>)              :: f (a -> b) -> f a -> f b
let h=h in (h <*>) ::               f a -> f b
            h      :: f (a -> b)
                             _____________
Monad m =>                  /.------.     \
(=<<)              :: (a -> m b) -> m a -> m b
let k=k in (k =<<) ::               m a -> m b
            k      :: (a -> m b)

Итак, да, каждый из них, (g <$>), (h <*>) или (k =<<), представляет собой своего рода приложение-функцию, продвинутое в "контекст" либо в функтор, либо в аппликативный функтор, либо в монаду. А (g $) - это просто обычное приложение обычной функции.

С функторами функции не влияют на f компонент вещи в целом. Они работают строго внутри и не могут повлиять на «упаковку».

В Applicatives функции заключены в f, который объединяется с оболочкой аргумента (как части приложения) для создания оболочки результата.

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

Мы можем рассматривать три оператора как своего рода маркировку функции, как математики любят писать, скажем, f', f^ или f* (и в исходной работе Эудженио Моджи ⁽¹⁾ f* именно то, что использовалась, обозначая продвигаемую функцию (f =<<)).

И, конечно же, с повышенными функциями :: f a -> f b мы можем объединить их в цепочки, потому что теперь типы выстраиваются в одну линию. Раскрутка - это то, что позволяет композиция.

⁽¹⁾ «Понятия вычислений и монад», Эудженио Моджи, июль 1991 г.

• подробнее о композиционности с изображением: Монады с Join () вместо Bind ()

Итак, функтор «волшебным образом работает внутри» «труб»; аппликативный - «сборные трубы, построенные из компонентов заранее»; а монады «строят трубопроводные сети на ходу». Иллюстрация: